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
  12 #ifndef SWIGCSHARP
  13 #define SWIGCSHARP
  14 #endif
  15
  16 #define SWIG_DIRECTORS
  17
  18
  19 #ifdef __cplusplus
  20 /* SwigValueWrapper is described in swig.swg */
  21 template<typename T> class SwigValueWrapper {
  22   struct SwigMovePointer {
  23     T *ptr;
  24     SwigMovePointer(T *p) : ptr(p) { }
  25     ~SwigMovePointer() { delete ptr; }
  26     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  27   } pointer;
  28   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  29   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
  30 public:
  31   SwigValueWrapper() : pointer(0) { }
  32   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  33   operator T&() const { return *pointer.ptr; }
  34   T *operator&() { return pointer.ptr; }
  35 };
  36
  37 template <typename T> T SwigValueInit() {
  38   return T();
  39 }
  40 #endif
  41
  42 /* -----------------------------------------------------------------------------
  43  *  This section contains generic SWIG labels for method/variable
  44  *  declarations/attributes, and other compiler dependent labels.
  45  * ----------------------------------------------------------------------------- */
  46
  47 /* template workaround for compilers that cannot correctly implement the C++ standard */
  48 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  49 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  50 #  define SWIGTEMPLATEDISAMBIGUATOR template
  51 # elif defined(__HP_aCC)
  52 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  53 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  54 #  define SWIGTEMPLATEDISAMBIGUATOR template
  55 # else
  56 #  define SWIGTEMPLATEDISAMBIGUATOR
  57 # endif
  58 #endif
  59
  60 /* inline attribute */
  61 #ifndef SWIGINLINE
  62 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  63 #   define SWIGINLINE inline
  64 # else
  65 #   define SWIGINLINE
  66 # endif
  67 #endif
  68
  69 /* attribute recognised by some compilers to avoid 'unused' warnings */
  70 #ifndef SWIGUNUSED
  71 # if defined(__GNUC__)
  72 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  73 #     define SWIGUNUSED __attribute__ ((__unused__))
  74 #   else
  75 #     define SWIGUNUSED
  76 #   endif
  77 # elif defined(__ICC)
  78 #   define SWIGUNUSED __attribute__ ((__unused__))
  79 # else
  80 #   define SWIGUNUSED
  81 # endif
  82 #endif
  83
  84 #ifndef SWIG_MSC_UNSUPPRESS_4505
  85 # if defined(_MSC_VER)
  86 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  87 # endif
  88 #endif
  89
  90 #ifndef SWIGUNUSEDPARM
  91 # ifdef __cplusplus
  92 #   define SWIGUNUSEDPARM(p)
  93 # else
  94 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  95 # endif
  96 #endif
  97
  98 /* internal SWIG method */
  99 #ifndef SWIGINTERN
 100 # define SWIGINTERN static SWIGUNUSED
 101 #endif
 102
 103 /* internal inline SWIG method */
 104 #ifndef SWIGINTERNINLINE
 105 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 106 #endif
 107
 108 /* exporting methods */
 109 #if defined(__GNUC__)
 110 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 111 #    ifndef GCC_HASCLASSVISIBILITY
 112 #      define GCC_HASCLASSVISIBILITY
 113 #    endif
 114 #  endif
 115 #endif
 116
 117 #ifndef SWIGEXPORT
 118 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 119 #   if defined(STATIC_LINKED)
 120 #     define SWIGEXPORT
 121 #   else
 122 #     define SWIGEXPORT __declspec(dllexport)
 123 #   endif
 124 # else
 125 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 126 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 127 #   else
 128 #     define SWIGEXPORT
 129 #   endif
 130 # endif
 131 #endif
 132
 133 /* calling conventions for Windows */
 134 #ifndef SWIGSTDCALL
 135 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 136 #   define SWIGSTDCALL __stdcall
 137 # else
 138 #   define SWIGSTDCALL
 139 # endif
 140 #endif
 141
 142 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 143 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 144 # define _CRT_SECURE_NO_DEPRECATE
 145 #endif
 146
 147 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 148 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 149 # define _SCL_SECURE_NO_DEPRECATE
 150 #endif
 151
 152 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 153 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 154 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 155 #endif
 156
 157 /* Intel's compiler complains if a variable which was never initialised is
 158  * cast to void, which is a common idiom which we use to indicate that we
 159  * are aware a variable isn't used.  So we just silence that warning.
 160  * See: https://github.com/swig/swig/issues/192 for more discussion.
 161  */
 162 #ifdef __INTEL_COMPILER
 163 # pragma warning disable 592
 164 #endif
 165
 166
 167 #include <stdlib.h>
 168 #include <string.h>
 169 #include <stdio.h>
 170
 171
 172 /* Support for throwing C# exceptions from C/C++. There are two types:
 173  * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
 174 typedef enum {
 175   SWIG_CSharpApplicationException,
 176   SWIG_CSharpArithmeticException,
 177   SWIG_CSharpDivideByZeroException,
 178   SWIG_CSharpIndexOutOfRangeException,
 179   SWIG_CSharpInvalidCastException,
 180   SWIG_CSharpInvalidOperationException,
 181   SWIG_CSharpIOException,
 182   SWIG_CSharpNullReferenceException,
 183   SWIG_CSharpOutOfMemoryException,
 184   SWIG_CSharpOverflowException,
 185   SWIG_CSharpSystemException
 186 } SWIG_CSharpExceptionCodes;
 187
 188 typedef enum {
 189   SWIG_CSharpArgumentException,
 190   SWIG_CSharpArgumentNullException,
 191   SWIG_CSharpArgumentOutOfRangeException
 192 } SWIG_CSharpExceptionArgumentCodes;
 193
 194 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
 195 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
 196
 197 typedef struct {
 198   SWIG_CSharpExceptionCodes code;
 199   SWIG_CSharpExceptionCallback_t callback;
 200 } SWIG_CSharpException_t;
 201
 202 typedef struct {
 203   SWIG_CSharpExceptionArgumentCodes code;
 204   SWIG_CSharpExceptionArgumentCallback_t callback;
 205 } SWIG_CSharpExceptionArgument_t;
 206
 207 SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
 208   { SWIG_CSharpApplicationException, NULL },
 209   { SWIG_CSharpArithmeticException, NULL },
 210   { SWIG_CSharpDivideByZeroException, NULL },
 211   { SWIG_CSharpIndexOutOfRangeException, NULL },
 212   { SWIG_CSharpInvalidCastException, NULL },
 213   { SWIG_CSharpInvalidOperationException, NULL },
 214   { SWIG_CSharpIOException, NULL },
 215   { SWIG_CSharpNullReferenceException, NULL },
 216   { SWIG_CSharpOutOfMemoryException, NULL },
 217   { SWIG_CSharpOverflowException, NULL },
 218   { SWIG_CSharpSystemException, NULL }
 219 };
 220
 221 SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 222   { SWIG_CSharpArgumentException, NULL },
 223   { SWIG_CSharpArgumentNullException, NULL },
 224   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 225 };
 226
 227 void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
 228   SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
 229   if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
 230     callback = SWIG_csharp_exceptions[code].callback;
 231   }
 232   callback(msg);
 233 }
 234
 235 void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
 236   SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
 237   if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
 238     callback = SWIG_csharp_exceptions_argument[code].callback;
 239   }
 240   callback(msg, param_name);
 241 }
 242
 243
 244 #ifdef __cplusplus
 245 extern "C"
 246 #endif
 247 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
 248                                                 SWIG_CSharpExceptionCallback_t applicationCallback,
 249                                                 SWIG_CSharpExceptionCallback_t arithmeticCallback,
 250                                                 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
 251                                                 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
 252                                                 SWIG_CSharpExceptionCallback_t invalidCastCallback,
 253                                                 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
 254                                                 SWIG_CSharpExceptionCallback_t ioCallback,
 255                                                 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
 256                                                 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
 257                                                 SWIG_CSharpExceptionCallback_t overflowCallback,
 258                                                 SWIG_CSharpExceptionCallback_t systemCallback) {
 259   SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
 260   SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
 261   SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
 262   SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
 263   SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
 264   SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
 265   SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
 266   SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
 267   SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
 268   SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
 269   SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
 270 }
 271
 272 #ifdef __cplusplus
 273 extern "C"
 274 #endif
 275 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
 276                                                 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
 277                                                 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
 278                                                 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
 279   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
 280   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
 281   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
 282 }
 283
 284
 285 /* Callback for returning strings to C# without leaking memory */
 286 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
 287 SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 288
 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
 428 #include <dali/public-api/math/matrix.h>
 429 #include <dali/public-api/math/matrix3.h>
 430 #include <dali/public-api/math/viewport.h>
 431 #include <dali/public-api/object/property-key.h>
 432 #include <dali/devel-api/object/csharp-type-info.h>
 433 #include <dali/devel-api/object/csharp-type-registry.h>
 434
 435 #include <dali/public-api/adaptor-framework/timer.h>
 436 #include <dali/public-api/adaptor-framework/style-change.h>
 437 #include <dali/devel-api/adaptor-framework/drag-and-drop-detector.h>
 438 #include <dali/devel-api/adaptor-framework/application-extensions.h>
 439
 440 #include <dali/devel-api/images/nine-patch-image.h>
 441
 442 #include <dali-toolkit/devel-api/builder/builder.h>
 443
 444 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 445 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 446
 447 #include <dali-toolkit/devel-api/controls/control-devel.h>
 448 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 449 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 450 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 451 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 452 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 454 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 455
 456 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 457 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 458 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 459
 460 #include <dali-toolkit/public-api/visuals/visual-properties.h>
 461 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
 462 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 463
 464 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 465 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 466
 467 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 468
 469 #include <dali-toolkit/devel-api/controls/text-controls/text-label-devel.h>
 470 #include <dali-toolkit/devel-api/text/text-enumerations-devel.h>
 471
 472 // add here SWIG version check
 473
 474 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 475 // disable Swig-dependent warnings
 476
 477 // 'identifier1' has C-linkage specified,
 478 // but returns UDT 'identifier2' which is incompatible with C
 479 #pragma warning(disable: 4190)
 480
 481 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 482 #pragma warning(disable: 4800)
 483
 484 // debug info too long etc etc
 485 #pragma warning(disable: 4786)
 486 #endif
 487
 488
 489 #include <stdexcept>
 490
 491
 492 #include <string>
 493
 494
 495 #include <vector>
 496 #include <algorithm>
 497 #include <stdexcept>
 498
 499
 500 #include <map>
 501 #include <algorithm>
 502 #include <stdexcept>
 503
 504
 505 #include <utility>
 506
 507
 508 typedef float floatp;
 509
 510 SWIGINTERN floatp *new_floatp(){
 511   return new float();
 512 }
 513 SWIGINTERN void delete_floatp(floatp *self){
 514   if (self) delete self;
 515 }
 516 SWIGINTERN void floatp_assign(floatp *self,float value){
 517   *self = value;
 518 }
 519 SWIGINTERN float floatp_value(floatp *self){
 520   return *self;
 521 }
 522 SWIGINTERN float *floatp_cast(floatp *self){
 523   return self;
 524 }
 525 SWIGINTERN floatp *floatp_frompointer(float *t){
 526   return (floatp *) t;
 527 }
 528
 529 typedef int intp;
 530
 531 SWIGINTERN intp *new_intp(){
 532   return new int();
 533 }
 534 SWIGINTERN void delete_intp(intp *self){
 535   if (self) delete self;
 536 }
 537 SWIGINTERN void intp_assign(intp *self,int value){
 538   *self = value;
 539 }
 540 SWIGINTERN int intp_value(intp *self){
 541   return *self;
 542 }
 543 SWIGINTERN int *intp_cast(intp *self){
 544   return self;
 545 }
 546 SWIGINTERN intp *intp_frompointer(int *t){
 547   return (intp *) t;
 548 }
 549
 550 typedef double doublep;
 551
 552 SWIGINTERN doublep *new_doublep(){
 553   return new double();
 554 }
 555 SWIGINTERN void delete_doublep(doublep *self){
 556   if (self) delete self;
 557 }
 558 SWIGINTERN void doublep_assign(doublep *self,double value){
 559   *self = value;
 560 }
 561 SWIGINTERN double doublep_value(doublep *self){
 562   return *self;
 563 }
 564 SWIGINTERN double *doublep_cast(doublep *self){
 565   return self;
 566 }
 567 SWIGINTERN doublep *doublep_frompointer(double *t){
 568   return (doublep *) t;
 569 }
 570
 571 typedef unsigned int uintp;
 572
 573 SWIGINTERN uintp *new_uintp(){
 574   return new unsigned int();
 575 }
 576 SWIGINTERN void delete_uintp(uintp *self){
 577   if (self) delete self;
 578 }
 579 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 580   *self = value;
 581 }
 582 SWIGINTERN unsigned int uintp_value(uintp *self){
 583   return *self;
 584 }
 585 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 586   return self;
 587 }
 588 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 589   return (uintp *) t;
 590 }
 591
 592 typedef unsigned short ushortp;
 593
 594 SWIGINTERN ushortp *new_ushortp(){
 595   return new unsigned short();
 596 }
 597 SWIGINTERN void delete_ushortp(ushortp *self){
 598   if (self) delete self;
 599 }
 600 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 601   *self = value;
 602 }
 603 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 604   return *self;
 605 }
 606 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 607   return self;
 608 }
 609 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 610   return (ushortp *) t;
 611 }
 612
 613 unsigned int int_to_uint(int x) {
 614    return (unsigned int) x;
 615 }
 616
 617
 618 using namespace Dali;
 619 using namespace Dali::Toolkit;
 620
 621 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 622 {
 623   bool result = false;
 624   try
 625   {
 626     // C++ code. DALi uses Handle <-> Body design pattern.
 627     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 628     // Handles in DALi can be converted into a boolean type
 629     // to check if the handle has a valid body attached to it.
 630     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 631     if( *self )
 632     {
 633       result = true;
 634     }
 635     else
 636     {
 637       result = false;
 638     }
 639   }
 640   catch (std::out_of_range& e)
 641   {
 642     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 643     return 0;
 644   }
 645   catch (std::exception& e)
 646   {
 647     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 648     return 0;
 649   }
 650   catch (DaliException e)
 651   {
 652     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 653     return 0;
 654   }
 655   catch (...)
 656   {
 657     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 658     return 0;
 659   }
 660   return result;
 661 }
 662
 663 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 664 {
 665   bool result = false;
 666   try
 667   {
 668     // C++ code. Check if two handles reference the same implemtion
 669     if( *self == rhs)
 670     {
 671       result = true;
 672     }
 673     else
 674     {
 675       result = false;
 676     }
 677   }
 678   catch (std::out_of_range& e)
 679   {
 680     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 681     return 0;
 682   }
 683   catch (std::exception& e)
 684   {
 685     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 686     return 0;
 687   }
 688   catch (DaliException e)
 689   {
 690     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 691     return 0;
 692   }
 693   catch (...)
 694   {
 695     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 696     return 0;
 697   }
 698   return result;
 699 }
 700
 701
 702 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 703      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 704    }
 705 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){
 706      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 707    }
 708 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 709         std::vector< Dali::TouchPoint >* pv = 0;
 710         if (capacity >= 0) {
 711           pv = new std::vector< Dali::TouchPoint >();
 712           pv->reserve(capacity);
 713        } else {
 714           throw std::out_of_range("capacity");
 715        }
 716        return pv;
 717       }
 718 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 719         if (index>=0 && index<(int)self->size())
 720           return (*self)[index];
 721         else
 722           throw std::out_of_range("index");
 723       }
 724 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(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 void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 731         if (index>=0 && index<(int)self->size())
 732           (*self)[index] = val;
 733         else
 734           throw std::out_of_range("index");
 735       }
 736 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 737         self->insert(self->end(), values.begin(), values.end());
 738       }
 739 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 740         if (index < 0)
 741           throw std::out_of_range("index");
 742         if (count < 0)
 743           throw std::out_of_range("count");
 744         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 745           throw std::invalid_argument("invalid range");
 746         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 747       }
 748 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 749         if (index>=0 && index<(int)self->size()+1)
 750           self->insert(self->begin()+index, x);
 751         else
 752           throw std::out_of_range("index");
 753       }
 754 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 755         if (index>=0 && index<(int)self->size()+1)
 756           self->insert(self->begin()+index, values.begin(), values.end());
 757         else
 758           throw std::out_of_range("index");
 759       }
 760 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 761         if (index>=0 && index<(int)self->size())
 762           self->erase(self->begin() + index);
 763         else
 764           throw std::out_of_range("index");
 765       }
 766 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 767         if (index < 0)
 768           throw std::out_of_range("index");
 769         if (count < 0)
 770           throw std::out_of_range("count");
 771         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 772           throw std::invalid_argument("invalid range");
 773         self->erase(self->begin()+index, self->begin()+index+count);
 774       }
 775 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 776         if (count < 0)
 777           throw std::out_of_range("count");
 778         return new std::vector< Dali::TouchPoint >(count, value);
 779       }
 780 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 781         std::reverse(self->begin(), self->end());
 782       }
 783 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 784         if (index < 0)
 785           throw std::out_of_range("index");
 786         if (count < 0)
 787           throw std::out_of_range("count");
 788         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 789           throw std::invalid_argument("invalid range");
 790         std::reverse(self->begin()+index, self->begin()+index+count);
 791       }
 792 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 793         if (index < 0)
 794           throw std::out_of_range("index");
 795         if (index+values.size() > self->size())
 796           throw std::out_of_range("index");
 797         std::copy(values.begin(), values.end(), self->begin()+index);
 798       }
 799 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 800          return self->Empty();
 801       }
 802 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 803         return self->GetConnectionCount();
 804       }
 805 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 806           self->Connect( func );
 807       }
 808 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 809           self->Disconnect( func );
 810       }
 811 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 812           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 813 /*@SWIG@*/ self->Emit( arg );
 814       }
 815 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 816          return self->Empty();
 817       }
 818 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 819         return self->GetConnectionCount();
 820       }
 821 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 822           self->Connect( func );
 823       }
 824 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 825           self->Disconnect( func );
 826       }
 827 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 828           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 829 /*@SWIG@*/ self->Emit( arg );
 830       }
 831 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 832          return self->Empty();
 833       }
 834 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){
 835         return self->GetConnectionCount();
 836       }
 837 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 *)){
 838           self->Connect( func );
 839       }
 840 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 *)){
 841           self->Disconnect( func );
 842       }
 843 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){
 844           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 845 /*@SWIG@*/ self->Emit( arg );
 846       }
 847 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 848          return self->Empty();
 849       }
 850 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 851         return self->GetConnectionCount();
 852       }
 853 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 854           self->Connect( func );
 855       }
 856 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 857           self->Disconnect( func );
 858       }
 859 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 860           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 861 /*@SWIG@*/ self->Emit( arg );
 862       }
 863 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 864          return self->Empty();
 865       }
 866 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 867         return self->GetConnectionCount();
 868       }
 869 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 870           self->Connect( func );
 871       }
 872 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 873           self->Disconnect( func );
 874       }
 875 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 876           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 877 /*@SWIG@*/ self->Emit( arg );
 878       }
 879 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){
 880          return self->Empty();
 881       }
 882 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){
 883         return self->GetConnectionCount();
 884       }
 885 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 &)){
 886         self->Connect( func );
 887       }
 888 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 &)){
 889         self->Disconnect( func );
 890       }
 891 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){
 892         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 893 /*@SWIG@*/ self->Emit( arg1, arg2 );
 894       }
 895 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){
 896          return self->Empty();
 897       }
 898 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){
 899         return self->GetConnectionCount();
 900       }
 901 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 &)){
 902         self->Connect( func );
 903       }
 904 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 &)){
 905         self->Disconnect( func );
 906       }
 907 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){
 908         return self->Emit( arg1, arg2 );
 909       }
 910 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){
 911          return self->Empty();
 912       }
 913 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){
 914         return self->GetConnectionCount();
 915       }
 916 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 &)){
 917         self->Connect( func );
 918       }
 919 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 &)){
 920         self->Disconnect( func );
 921       }
 922 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){
 923         return self->Emit( arg1, arg2 );
 924       }
 925 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){
 926          return self->Empty();
 927       }
 928 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){
 929         return self->GetConnectionCount();
 930       }
 931 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 &)){
 932         self->Connect( func );
 933       }
 934 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 &)){
 935         self->Disconnect( func );
 936       }
 937 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){
 938         return self->Emit( arg1, arg2 );
 939       }
 940 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 941          return self->Empty();
 942       }
 943 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 944         return self->GetConnectionCount();
 945       }
 946 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 947           self->Connect( func );
 948       }
 949 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 950           self->Disconnect( func );
 951       }
 952 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 953           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 954 /*@SWIG@*/ self->Emit( arg );
 955       }
 956 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 957          return self->Empty();
 958       }
 959 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){
 960         return self->GetConnectionCount();
 961       }
 962 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 &)){
 963           self->Connect( func );
 964       }
 965 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 &)){
 966           self->Disconnect( func );
 967       }
 968 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){
 969           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 970 /*@SWIG@*/ self->Emit( arg );
 971       }
 972 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 973          return self->Empty();
 974       }
 975 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){
 976         return self->GetConnectionCount();
 977       }
 978 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 &)){
 979           self->Connect( func );
 980       }
 981 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 &)){
 982           self->Disconnect( func );
 983       }
 984 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){
 985           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 986 /*@SWIG@*/ self->Emit( arg );
 987       }
 988 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 989          return self->Empty();
 990       }
 991 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){
 992         return self->GetConnectionCount();
 993       }
 994 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 &)){
 995           self->Connect( func );
 996       }
 997 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 &)){
 998           self->Disconnect( func );
 999       }
1000 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){
1001           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1002 /*@SWIG@*/ self->Emit( arg );
1003       }
1004 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){
1005          return self->Empty();
1006       }
1007 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){
1008         return self->GetConnectionCount();
1009       }
1010 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 &)){
1011         self->Connect( func );
1012       }
1013 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 &)){
1014         self->Disconnect( func );
1015       }
1016 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){
1017         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1018 /*@SWIG@*/ self->Emit( arg1, arg2 );
1019       }
1020 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){
1021          return self->Empty();
1022       }
1023 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){
1024         return self->GetConnectionCount();
1025       }
1026 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 &)){
1027         self->Connect( func );
1028       }
1029 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 &)){
1030         self->Disconnect( func );
1031       }
1032 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){
1033         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1034 /*@SWIG@*/ self->Emit( arg1, arg2 );
1035       }
1036 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){
1037          return self->Empty();
1038       }
1039 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){
1040         return self->GetConnectionCount();
1041       }
1042 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 &)){
1043         self->Connect( func );
1044       }
1045 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 &)){
1046         self->Disconnect( func );
1047       }
1048 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){
1049         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1050 /*@SWIG@*/ self->Emit( arg1, arg2 );
1051       }
1052 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1053          return self->Empty();
1054       }
1055 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1056         return self->GetConnectionCount();
1057       }
1058 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1059           self->Connect( func );
1060       }
1061 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1062           self->Disconnect( func );
1063       }
1064 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1065           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1066 /*@SWIG@*/ self->Emit( arg );
1067       }
1068 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){
1069          return self->Empty();
1070       }
1071 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){
1072         return self->GetConnectionCount();
1073       }
1074 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)){
1075           return self->Connect( func );
1076       }
1077 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)){
1078           self->Disconnect( func );
1079       }
1080 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){
1081           self->Emit( arg1, arg3 );
1082       }
1083 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){
1084          return self->Empty();
1085       }
1086 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){
1087         return self->GetConnectionCount();
1088       }
1089 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)){
1090           return self->Connect( func );
1091       }
1092 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)){
1093           self->Disconnect( func );
1094       }
1095 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){
1096           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1097 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1098       }
1099
1100 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1101          return self->Empty();
1102       }
1103 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1104         return self->GetConnectionCount();
1105       }
1106 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1107           self->Connect( func );
1108       }
1109 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1110           self->Disconnect( func );
1111       }
1112 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1113           return self->Emit();
1114       }
1115
1116 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1117         std::vector< unsigned int >* pv = 0;
1118         if (capacity >= 0) {
1119           pv = new std::vector< unsigned int >();
1120           pv->reserve(capacity);
1121        } else {
1122           throw std::out_of_range("capacity");
1123        }
1124        return pv;
1125       }
1126 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1127         if (index>=0 && index<(int)self->size())
1128           return (*self)[index];
1129         else
1130           throw std::out_of_range("index");
1131       }
1132 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(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 void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1139         if (index>=0 && index<(int)self->size())
1140           (*self)[index] = val;
1141         else
1142           throw std::out_of_range("index");
1143       }
1144 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1145         self->insert(self->end(), values.begin(), values.end());
1146       }
1147 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1148         if (index < 0)
1149           throw std::out_of_range("index");
1150         if (count < 0)
1151           throw std::out_of_range("count");
1152         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1153           throw std::invalid_argument("invalid range");
1154         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1155       }
1156 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1157         if (index>=0 && index<(int)self->size()+1)
1158           self->insert(self->begin()+index, x);
1159         else
1160           throw std::out_of_range("index");
1161       }
1162 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1163         if (index>=0 && index<(int)self->size()+1)
1164           self->insert(self->begin()+index, values.begin(), values.end());
1165         else
1166           throw std::out_of_range("index");
1167       }
1168 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1169         if (index>=0 && index<(int)self->size())
1170           self->erase(self->begin() + index);
1171         else
1172           throw std::out_of_range("index");
1173       }
1174 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1175         if (index < 0)
1176           throw std::out_of_range("index");
1177         if (count < 0)
1178           throw std::out_of_range("count");
1179         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1180           throw std::invalid_argument("invalid range");
1181         self->erase(self->begin()+index, self->begin()+index+count);
1182       }
1183 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1184         if (count < 0)
1185           throw std::out_of_range("count");
1186         return new std::vector< unsigned int >(count, value);
1187       }
1188 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1189         std::reverse(self->begin(), self->end());
1190       }
1191 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1192         if (index < 0)
1193           throw std::out_of_range("index");
1194         if (count < 0)
1195           throw std::out_of_range("count");
1196         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1197           throw std::invalid_argument("invalid range");
1198         std::reverse(self->begin()+index, self->begin()+index+count);
1199       }
1200 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1201         if (index < 0)
1202           throw std::out_of_range("index");
1203         if (index+values.size() > self->size())
1204           throw std::out_of_range("index");
1205         std::copy(values.begin(), values.end(), self->begin()+index);
1206       }
1207 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1208         return std::find(self->begin(), self->end(), value) != self->end();
1209       }
1210 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1211         int index = -1;
1212         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1213         if (it != self->end())
1214           index = (int)(it - self->begin());
1215         return index;
1216       }
1217 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1218         int index = -1;
1219         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1220         if (rit != self->rend())
1221           index = (int)(self->rend() - 1 - rit);
1222         return index;
1223       }
1224 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1225         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1226         if (it != self->end()) {
1227           self->erase(it);
1228           return true;
1229         }
1230         return false;
1231       }
1232 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){
1233         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1234         if (capacity >= 0) {
1235           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1236           pv->reserve(capacity);
1237        } else {
1238           throw std::out_of_range("capacity");
1239        }
1240        return pv;
1241       }
1242 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){
1243         if (index>=0 && index<(int)self->size())
1244           return (*self)[index];
1245         else
1246           throw std::out_of_range("index");
1247       }
1248 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){
1249         if (index>=0 && index<(int)self->size())
1250           return (*self)[index];
1251         else
1252           throw std::out_of_range("index");
1253       }
1254 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){
1255         if (index>=0 && index<(int)self->size())
1256           (*self)[index] = val;
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__AddRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1261         self->insert(self->end(), values.begin(), values.end());
1262       }
1263 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){
1264         if (index < 0)
1265           throw std::out_of_range("index");
1266         if (count < 0)
1267           throw std::out_of_range("count");
1268         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1269           throw std::invalid_argument("invalid range");
1270         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1271       }
1272 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){
1273         if (index>=0 && index<(int)self->size()+1)
1274           self->insert(self->begin()+index, x);
1275         else
1276           throw std::out_of_range("index");
1277       }
1278 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){
1279         if (index>=0 && index<(int)self->size()+1)
1280           self->insert(self->begin()+index, values.begin(), values.end());
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__RemoveAt(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1285         if (index>=0 && index<(int)self->size())
1286           self->erase(self->begin() + index);
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__RemoveRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1291         if (index < 0)
1292           throw std::out_of_range("index");
1293         if (count < 0)
1294           throw std::out_of_range("count");
1295         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1296           throw std::invalid_argument("invalid range");
1297         self->erase(self->begin()+index, self->begin()+index+count);
1298       }
1299 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){
1300         if (count < 0)
1301           throw std::out_of_range("count");
1302         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1303       }
1304 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){
1305         std::reverse(self->begin(), self->end());
1306       }
1307 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){
1308         if (index < 0)
1309           throw std::out_of_range("index");
1310         if (count < 0)
1311           throw std::out_of_range("count");
1312         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1313           throw std::invalid_argument("invalid range");
1314         std::reverse(self->begin()+index, self->begin()+index+count);
1315       }
1316 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){
1317         if (index < 0)
1318           throw std::out_of_range("index");
1319         if (index+values.size() > self->size())
1320           throw std::out_of_range("index");
1321         std::copy(values.begin(), values.end(), self->begin()+index);
1322       }
1323 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1324         std::vector< Dali::Actor >* pv = 0;
1325         if (capacity >= 0) {
1326           pv = new std::vector< Dali::Actor >();
1327           pv->reserve(capacity);
1328        } else {
1329           throw std::out_of_range("capacity");
1330        }
1331        return pv;
1332       }
1333 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1334         if (index>=0 && index<(int)self->size())
1335           return (*self)[index];
1336         else
1337           throw std::out_of_range("index");
1338       }
1339 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(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 void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1346         if (index>=0 && index<(int)self->size())
1347           (*self)[index] = val;
1348         else
1349           throw std::out_of_range("index");
1350       }
1351 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1352         self->insert(self->end(), values.begin(), values.end());
1353       }
1354 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1355         if (index < 0)
1356           throw std::out_of_range("index");
1357         if (count < 0)
1358           throw std::out_of_range("count");
1359         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1360           throw std::invalid_argument("invalid range");
1361         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1362       }
1363 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1364         if (index>=0 && index<(int)self->size()+1)
1365           self->insert(self->begin()+index, x);
1366         else
1367           throw std::out_of_range("index");
1368       }
1369 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1370         if (index>=0 && index<(int)self->size()+1)
1371           self->insert(self->begin()+index, values.begin(), values.end());
1372         else
1373           throw std::out_of_range("index");
1374       }
1375 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1376         if (index>=0 && index<(int)self->size())
1377           self->erase(self->begin() + index);
1378         else
1379           throw std::out_of_range("index");
1380       }
1381 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1382         if (index < 0)
1383           throw std::out_of_range("index");
1384         if (count < 0)
1385           throw std::out_of_range("count");
1386         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1387           throw std::invalid_argument("invalid range");
1388         self->erase(self->begin()+index, self->begin()+index+count);
1389       }
1390 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1391         if (count < 0)
1392           throw std::out_of_range("count");
1393         return new std::vector< Dali::Actor >(count, value);
1394       }
1395 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1396         std::reverse(self->begin(), self->end());
1397       }
1398 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1399         if (index < 0)
1400           throw std::out_of_range("index");
1401         if (count < 0)
1402           throw std::out_of_range("count");
1403         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1404           throw std::invalid_argument("invalid range");
1405         std::reverse(self->begin()+index, self->begin()+index+count);
1406       }
1407 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1408         if (index < 0)
1409           throw std::out_of_range("index");
1410         if (index+values.size() > self->size())
1411           throw std::out_of_range("index");
1412         std::copy(values.begin(), values.end(), self->begin()+index);
1413       }
1414 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1415          return self->Empty();
1416       }
1417 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1418         return self->GetConnectionCount();
1419       }
1420 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 &)){
1421           self->Connect( func );
1422       }
1423 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 &)){
1424           self->Disconnect( func );
1425       }
1426 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){
1427           return self->Emit( arg );
1428       }
1429 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){
1430          return self->Empty();
1431       }
1432 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){
1433         return self->GetConnectionCount();
1434       }
1435 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)){
1436         self->Connect( func );
1437       }
1438 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)){
1439         self->Disconnect( func );
1440       }
1441 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){
1442         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1443 /*@SWIG@*/ self->Emit( arg1, arg2 );
1444       }
1445 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1446          return self->Empty();
1447       }
1448 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){
1449         return self->GetConnectionCount();
1450       }
1451 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)){
1452         self->Connect( func );
1453       }
1454 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)){
1455         self->Disconnect( func );
1456       }
1457 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){
1458         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1459 /*@SWIG@*/ self->Emit( arg1, arg2 );
1460       }
1461 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1462          return self->Empty();
1463       }
1464 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1465         return self->GetConnectionCount();
1466       }
1467 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)){
1468         self->Connect( func );
1469       }
1470 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)){
1471         self->Disconnect( func );
1472       }
1473 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){
1474         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1475 /*@SWIG@*/ self->Emit( arg1, arg2 );
1476       }
1477 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){
1478          return self->Empty();
1479       }
1480 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){
1481         return self->GetConnectionCount();
1482       }
1483 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)){
1484         self->Connect( func );
1485       }
1486 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)){
1487         self->Disconnect( func );
1488       }
1489 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){
1490         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1491 /*@SWIG@*/ self->Emit( arg1, arg2 );
1492       }
1493 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1494          return self->Empty();
1495       }
1496 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1497         return self->GetConnectionCount();
1498       }
1499 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)){
1500           self->Connect( func );
1501       }
1502 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)){
1503           self->Disconnect( func );
1504       }
1505 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1506           return self->Emit( arg );
1507       }
1508 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1509          return self->Empty();
1510       }
1511 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1512         return self->GetConnectionCount();
1513       }
1514 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)){
1515           self->Connect( func );
1516       }
1517 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)){
1518           self->Disconnect( func );
1519       }
1520 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1521           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1522 /*@SWIG@*/ self->Emit( arg );
1523       }
1524 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){
1525          return self->Empty();
1526       }
1527 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){
1528         return self->GetConnectionCount();
1529       }
1530 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)){
1531           return self->Connect( func );
1532       }
1533 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)){
1534           self->Disconnect( func );
1535       }
1536 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){
1537           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1538 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1539       }
1540 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1541          return self->Empty();
1542       }
1543 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1544         return self->GetConnectionCount();
1545       }
1546 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)){
1547           self->Connect( func );
1548       }
1549 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)){
1550           self->Disconnect( func );
1551       }
1552 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1553           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1554 /*@SWIG@*/ self->Emit( arg );
1555       }
1556 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){
1557          return self->Empty();
1558       }
1559 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){
1560         return self->GetConnectionCount();
1561       }
1562 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)){
1563           return self->Connect( func );
1564       }
1565 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)){
1566           self->Disconnect( func );
1567       }
1568 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){
1569           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1570 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1571       }
1572 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){
1573          return self->Empty();
1574       }
1575 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){
1576         return self->GetConnectionCount();
1577       }
1578 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 &)){
1579           self->Connect( func );
1580       }
1581 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 &)){
1582           self->Disconnect( func );
1583       }
1584 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){
1585           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1586 /*@SWIG@*/ self->Emit( arg );
1587       }
1588 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1589          return self->Empty();
1590       }
1591 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){
1592         return self->GetConnectionCount();
1593       }
1594 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 &)){
1595           self->Connect( func );
1596       }
1597 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 &)){
1598           self->Disconnect( func );
1599       }
1600 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){
1601           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1602 /*@SWIG@*/ self->Emit( arg );
1603       }
1604
1605
1606 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){
1607          return self->Empty();
1608       }
1609 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){
1610         return self->GetConnectionCount();
1611       }
1612 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 &)){
1613         self->Connect( func );
1614       }
1615 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 &)){
1616         self->Disconnect( func );
1617       }
1618 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){
1619         return self->Emit( arg1, arg2 );
1620       }
1621 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1622          return self->Empty();
1623       }
1624 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1625         return self->GetConnectionCount();
1626       }
1627 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)){
1628           self->Connect( func );
1629       }
1630 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)){
1631           self->Disconnect( func );
1632       }
1633 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1634           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1635 /*@SWIG@*/ self->Emit( arg );
1636       }
1637 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1638          return self->Empty();
1639       }
1640 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1641         return self->GetConnectionCount();
1642       }
1643 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 &)){
1644           self->Connect( func );
1645       }
1646 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 &)){
1647           self->Disconnect( func );
1648       }
1649 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){
1650           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1651 /*@SWIG@*/ self->Emit( arg );
1652       }
1653 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1654          return self->Empty();
1655       }
1656 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){
1657         return self->GetConnectionCount();
1658       }
1659 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)){
1660         self->Connect( func );
1661       }
1662 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)){
1663         self->Disconnect( func );
1664       }
1665 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){
1666         return self->Emit( arg1, arg2 );
1667       }
1668 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1669          return self->Empty();
1670       }
1671 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){
1672         return self->GetConnectionCount();
1673       }
1674 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)){
1675         self->Connect( func );
1676       }
1677 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)){
1678         self->Disconnect( func );
1679       }
1680 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){
1681         return self->Emit( arg1, arg2 );
1682       }
1683
1684
1685 /* ---------------------------------------------------
1686  * C++ director class methods
1687  * --------------------------------------------------- */
1688
1689 #include "dali_wrap.h"
1690
1691 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1692   swig_init_callbacks();
1693 }
1694
1695 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1696
1697 }
1698
1699
1700 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1701   int jdepth  ;
1702
1703   if (!swig_callbackOnStageConnection) {
1704     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1705     return;
1706   } else {
1707     jdepth = depth;
1708     swig_callbackOnStageConnection(jdepth);
1709   }
1710 }
1711
1712 void SwigDirector_ViewImpl::OnStageDisconnection() {
1713   if (!swig_callbackOnStageDisconnection) {
1714     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1715     return;
1716   } else {
1717     swig_callbackOnStageDisconnection();
1718   }
1719 }
1720
1721 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1722   void * jchild = 0 ;
1723
1724   if (!swig_callbackOnChildAdd) {
1725     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1726     return;
1727   } else {
1728     jchild = (Dali::Actor *) &child;
1729     swig_callbackOnChildAdd(jchild);
1730   }
1731 }
1732
1733 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1734   void * jchild = 0 ;
1735
1736   if (!swig_callbackOnChildRemove) {
1737     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1738     return;
1739   } else {
1740     jchild = (Dali::Actor *) &child;
1741     swig_callbackOnChildRemove(jchild);
1742   }
1743 }
1744
1745 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1746   int jindex  ;
1747   void * jpropertyValue  ;
1748
1749   if (!swig_callbackOnPropertySet) {
1750     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1751     return;
1752   } else {
1753     jindex = index;
1754     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1755     swig_callbackOnPropertySet(jindex, jpropertyValue);
1756   }
1757 }
1758
1759 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1760   void * jtargetSize = 0 ;
1761
1762   if (!swig_callbackOnSizeSet) {
1763     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1764     return;
1765   } else {
1766     jtargetSize = (Dali::Vector3 *) &targetSize;
1767     swig_callbackOnSizeSet(jtargetSize);
1768   }
1769 }
1770
1771 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1772   void * janimation = 0 ;
1773   void * jtargetSize = 0 ;
1774
1775   if (!swig_callbackOnSizeAnimation) {
1776     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1777     return;
1778   } else {
1779     janimation = (Dali::Animation *) &animation;
1780     jtargetSize = (Dali::Vector3 *) &targetSize;
1781     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1782   }
1783 }
1784
1785 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1786   bool c_result = SwigValueInit< bool >() ;
1787   unsigned int jresult = 0 ;
1788   void * jarg0 = 0 ;
1789
1790   if (!swig_callbackOnTouchEvent) {
1791     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1792   } else {
1793     jarg0 = (Dali::TouchEvent *) &event;
1794     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1795     c_result = jresult ? true : false;
1796   }
1797   return c_result;
1798 }
1799
1800 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1801   bool c_result = SwigValueInit< bool >() ;
1802   unsigned int jresult = 0 ;
1803   void * jarg0 = 0 ;
1804
1805   if (!swig_callbackOnHoverEvent) {
1806     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1807   } else {
1808     jarg0 = (Dali::HoverEvent *) &event;
1809     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1810     c_result = jresult ? true : false;
1811   }
1812   return c_result;
1813 }
1814
1815 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1816   bool c_result = SwigValueInit< bool >() ;
1817   unsigned int jresult = 0 ;
1818   void * jarg0 = 0 ;
1819
1820   if (!swig_callbackOnKeyEvent) {
1821     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1822   } else {
1823     jarg0 = (Dali::KeyEvent *) &event;
1824     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1825     c_result = jresult ? true : false;
1826   }
1827   return c_result;
1828 }
1829
1830 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1831   bool c_result = SwigValueInit< bool >() ;
1832   unsigned int jresult = 0 ;
1833   void * jarg0 = 0 ;
1834
1835   if (!swig_callbackOnWheelEvent) {
1836     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1837   } else {
1838     jarg0 = (Dali::WheelEvent *) &event;
1839     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1840     c_result = jresult ? true : false;
1841   }
1842   return c_result;
1843 }
1844
1845 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1846   void * jsize = 0 ;
1847   void * jcontainer = 0 ;
1848
1849   if (!swig_callbackOnRelayout) {
1850     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1851     return;
1852   } else {
1853     jsize = (Dali::Vector2 *) &size;
1854     jcontainer = (Dali::RelayoutContainer *) &container;
1855     swig_callbackOnRelayout(jsize, jcontainer);
1856   }
1857 }
1858
1859 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1860   int jpolicy  ;
1861   int jdimension  ;
1862
1863   if (!swig_callbackOnSetResizePolicy) {
1864     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1865     return;
1866   } else {
1867     jpolicy = (int)policy;
1868     jdimension = (int)dimension;
1869     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1870   }
1871 }
1872
1873 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1874   Dali::Vector3 c_result ;
1875   void * jresult = 0 ;
1876
1877   if (!swig_callbackGetNaturalSize) {
1878     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1879   } else {
1880     jresult = (void *) swig_callbackGetNaturalSize();
1881     if (!jresult) {
1882       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1883       return c_result;
1884     }
1885     c_result = *(Dali::Vector3 *)jresult;
1886   }
1887   return c_result;
1888 }
1889
1890 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
1891   float c_result = SwigValueInit< float >() ;
1892   float jresult = 0 ;
1893   void * jchild = 0 ;
1894   int jdimension  ;
1895
1896   if (!swig_callbackCalculateChildSize) {
1897     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
1898   } else {
1899     jchild = (Dali::Actor *) &child;
1900     jdimension = (int)dimension;
1901     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
1902     c_result = (float)jresult;
1903   }
1904   return c_result;
1905 }
1906
1907 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
1908   float c_result = SwigValueInit< float >() ;
1909   float jresult = 0 ;
1910   float jwidth  ;
1911
1912   if (!swig_callbackGetHeightForWidth) {
1913     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
1914   } else {
1915     jwidth = width;
1916     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
1917     c_result = (float)jresult;
1918   }
1919   return c_result;
1920 }
1921
1922 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
1923   float c_result = SwigValueInit< float >() ;
1924   float jresult = 0 ;
1925   float jheight  ;
1926
1927   if (!swig_callbackGetWidthForHeight) {
1928     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
1929   } else {
1930     jheight = height;
1931     jresult = (float) swig_callbackGetWidthForHeight(jheight);
1932     c_result = (float)jresult;
1933   }
1934   return c_result;
1935 }
1936
1937 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
1938   bool c_result = SwigValueInit< bool >() ;
1939   unsigned int jresult = 0 ;
1940   int jdimension  ;
1941
1942   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
1943     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
1944   } else {
1945     jdimension = (int)dimension;
1946     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
1947     c_result = jresult ? true : false;
1948   }
1949   return c_result;
1950 }
1951
1952 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
1953   int jdimension  ;
1954
1955   if (!swig_callbackOnCalculateRelayoutSize) {
1956     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
1957     return;
1958   } else {
1959     jdimension = (int)dimension;
1960     swig_callbackOnCalculateRelayoutSize(jdimension);
1961   }
1962 }
1963
1964 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
1965   float jsize  ;
1966   int jdimension  ;
1967
1968   if (!swig_callbackOnLayoutNegotiated) {
1969     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
1970     return;
1971   } else {
1972     jsize = size;
1973     jdimension = (int)dimension;
1974     swig_callbackOnLayoutNegotiated(jsize, jdimension);
1975   }
1976 }
1977
1978 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
1979   return Dali::CustomActorImpl::GetExtension();
1980 }
1981
1982 void SwigDirector_ViewImpl::OnInitialize() {
1983   if (!swig_callbackOnInitialize) {
1984     Dali::Toolkit::Internal::Control::OnInitialize();
1985     return;
1986   } else {
1987     swig_callbackOnInitialize();
1988   }
1989 }
1990
1991 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
1992   void * jchild = 0 ;
1993
1994   if (!swig_callbackOnControlChildAdd) {
1995     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
1996     return;
1997   } else {
1998     jchild = (Dali::Actor *) &child;
1999     swig_callbackOnControlChildAdd(jchild);
2000   }
2001 }
2002
2003 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
2004   void * jchild = 0 ;
2005
2006   if (!swig_callbackOnControlChildRemove) {
2007     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
2008     return;
2009   } else {
2010     jchild = (Dali::Actor *) &child;
2011     swig_callbackOnControlChildRemove(jchild);
2012   }
2013 }
2014
2015 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2016   void * jstyleManager  ;
2017   int jchange  ;
2018
2019   if (!swig_callbackOnStyleChange) {
2020     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2021     return;
2022   } else {
2023     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2024     jchange = (int)change;
2025     swig_callbackOnStyleChange(jstyleManager, jchange);
2026   }
2027 }
2028
2029 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2030   bool c_result = SwigValueInit< bool >() ;
2031   unsigned int jresult = 0 ;
2032
2033   if (!swig_callbackOnAccessibilityActivated) {
2034     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2035   } else {
2036     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2037     c_result = jresult ? true : false;
2038   }
2039   return c_result;
2040 }
2041
2042 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2043   bool c_result = SwigValueInit< bool >() ;
2044   unsigned int jresult = 0 ;
2045   void * jgesture  ;
2046
2047   if (!swig_callbackOnAccessibilityPan) {
2048     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2049   } else {
2050     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2051     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2052     c_result = jresult ? true : false;
2053   }
2054   return c_result;
2055 }
2056
2057 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2058   bool c_result = SwigValueInit< bool >() ;
2059   unsigned int jresult = 0 ;
2060   void * jtouchEvent = 0 ;
2061
2062   if (!swig_callbackOnAccessibilityTouch) {
2063     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2064   } else {
2065     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2066     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2067     c_result = jresult ? true : false;
2068   }
2069   return c_result;
2070 }
2071
2072 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2073   bool c_result = SwigValueInit< bool >() ;
2074   unsigned int jresult = 0 ;
2075   unsigned int jisIncrease  ;
2076
2077   if (!swig_callbackOnAccessibilityValueChange) {
2078     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2079   } else {
2080     jisIncrease = isIncrease;
2081     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2082     c_result = jresult ? true : false;
2083   }
2084   return c_result;
2085 }
2086
2087 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2088   bool c_result = SwigValueInit< bool >() ;
2089   unsigned int jresult = 0 ;
2090
2091   if (!swig_callbackOnAccessibilityZoom) {
2092     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2093   } else {
2094     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2095     c_result = jresult ? true : false;
2096   }
2097   return c_result;
2098 }
2099
2100 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2101   if (!swig_callbackOnKeyInputFocusGained) {
2102     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2103     return;
2104   } else {
2105     swig_callbackOnKeyInputFocusGained();
2106   }
2107 }
2108
2109 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2110   if (!swig_callbackOnKeyInputFocusLost) {
2111     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2112     return;
2113   } else {
2114     swig_callbackOnKeyInputFocusLost();
2115   }
2116 }
2117
2118 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2119   Dali::Actor c_result ;
2120   void * jresult = 0 ;
2121   void * jcurrentFocusedActor  ;
2122   int jdirection  ;
2123   unsigned int jloopEnabled  ;
2124
2125   if (!swig_callbackGetNextKeyboardFocusableActor) {
2126     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2127   } else {
2128     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2129     jdirection = (int)direction;
2130     jloopEnabled = loopEnabled;
2131     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2132     if (!jresult) {
2133       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2134       return c_result;
2135     }
2136     c_result = *(Dali::Actor *)jresult;
2137   }
2138   return c_result;
2139 }
2140
2141 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2142   void * jcommitedFocusableActor  ;
2143
2144   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2145     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2146     return;
2147   } else {
2148     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2149     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2150   }
2151 }
2152
2153 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2154   bool c_result = SwigValueInit< bool >() ;
2155   unsigned int jresult = 0 ;
2156
2157   if (!swig_callbackOnKeyboardEnter) {
2158     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2159   } else {
2160     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2161     c_result = jresult ? true : false;
2162   }
2163   return c_result;
2164 }
2165
2166 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2167   void * jpinch = 0 ;
2168
2169   if (!swig_callbackOnPinch) {
2170     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2171     return;
2172   } else {
2173     jpinch = (Dali::PinchGesture *) &pinch;
2174     swig_callbackOnPinch(jpinch);
2175   }
2176 }
2177
2178 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2179   void * jpan = 0 ;
2180
2181   if (!swig_callbackOnPan) {
2182     Dali::Toolkit::Internal::Control::OnPan(pan);
2183     return;
2184   } else {
2185     jpan = (Dali::PanGesture *) &pan;
2186     swig_callbackOnPan(jpan);
2187   }
2188 }
2189
2190 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2191   void * jtap = 0 ;
2192
2193   if (!swig_callbackOnTap) {
2194     Dali::Toolkit::Internal::Control::OnTap(tap);
2195     return;
2196   } else {
2197     jtap = (Dali::TapGesture *) &tap;
2198     swig_callbackOnTap(jtap);
2199   }
2200 }
2201
2202 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2203   void * jlongPress = 0 ;
2204
2205   if (!swig_callbackOnLongPress) {
2206     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2207     return;
2208   } else {
2209     jlongPress = (Dali::LongPressGesture *) &longPress;
2210     swig_callbackOnLongPress(jlongPress);
2211   }
2212 }
2213
2214 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2215   void * jslotObserver = 0 ;
2216   void * jcallback = 0 ;
2217
2218   if (!swig_callbackSignalConnected) {
2219     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2220     return;
2221   } else {
2222     jslotObserver = (void *) slotObserver;
2223     jcallback = (void *) callback;
2224     swig_callbackSignalConnected(jslotObserver, jcallback);
2225   }
2226 }
2227
2228 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2229   void * jslotObserver = 0 ;
2230   void * jcallback = 0 ;
2231
2232   if (!swig_callbackSignalDisconnected) {
2233     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2234     return;
2235   } else {
2236     jslotObserver = (void *) slotObserver;
2237     jcallback = (void *) callback;
2238     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2239   }
2240 }
2241
2242 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2243   return Dali::Toolkit::Internal::Control::GetControlExtension();
2244 }
2245
2246 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) {
2247   swig_callbackOnStageConnection = callbackOnStageConnection;
2248   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2249   swig_callbackOnChildAdd = callbackOnChildAdd;
2250   swig_callbackOnChildRemove = callbackOnChildRemove;
2251   swig_callbackOnPropertySet = callbackOnPropertySet;
2252   swig_callbackOnSizeSet = callbackOnSizeSet;
2253   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2254   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2255   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2256   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2257   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2258   swig_callbackOnRelayout = callbackOnRelayout;
2259   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2260   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2261   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2262   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2263   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2264   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2265   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2266   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2267   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2268   swig_callbackOnInitialize = callbackOnInitialize;
2269   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2270   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2271   swig_callbackOnStyleChange = callbackOnStyleChange;
2272   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2273   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2274   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2275   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2276   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2277   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2278   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2279   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2280   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2281   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2282   swig_callbackOnPinch = callbackOnPinch;
2283   swig_callbackOnPan = callbackOnPan;
2284   swig_callbackOnTap = callbackOnTap;
2285   swig_callbackOnLongPress = callbackOnLongPress;
2286   swig_callbackSignalConnected = callbackSignalConnected;
2287   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2288 }
2289
2290 void SwigDirector_ViewImpl::swig_init_callbacks() {
2291   swig_callbackOnStageConnection = 0;
2292   swig_callbackOnStageDisconnection = 0;
2293   swig_callbackOnChildAdd = 0;
2294   swig_callbackOnChildRemove = 0;
2295   swig_callbackOnPropertySet = 0;
2296   swig_callbackOnSizeSet = 0;
2297   swig_callbackOnSizeAnimation = 0;
2298   swig_callbackOnTouchEvent = 0;
2299   swig_callbackOnHoverEvent = 0;
2300   swig_callbackOnKeyEvent = 0;
2301   swig_callbackOnWheelEvent = 0;
2302   swig_callbackOnRelayout = 0;
2303   swig_callbackOnSetResizePolicy = 0;
2304   swig_callbackGetNaturalSize = 0;
2305   swig_callbackCalculateChildSize = 0;
2306   swig_callbackGetHeightForWidth = 0;
2307   swig_callbackGetWidthForHeight = 0;
2308   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2309   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2310   swig_callbackOnCalculateRelayoutSize = 0;
2311   swig_callbackOnLayoutNegotiated = 0;
2312   swig_callbackOnInitialize = 0;
2313   swig_callbackOnControlChildAdd = 0;
2314   swig_callbackOnControlChildRemove = 0;
2315   swig_callbackOnStyleChange = 0;
2316   swig_callbackOnAccessibilityActivated = 0;
2317   swig_callbackOnAccessibilityPan = 0;
2318   swig_callbackOnAccessibilityTouch = 0;
2319   swig_callbackOnAccessibilityValueChange = 0;
2320   swig_callbackOnAccessibilityZoom = 0;
2321   swig_callbackOnKeyInputFocusGained = 0;
2322   swig_callbackOnKeyInputFocusLost = 0;
2323   swig_callbackGetNextKeyboardFocusableActor = 0;
2324   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2325   swig_callbackOnKeyboardEnter = 0;
2326   swig_callbackOnPinch = 0;
2327   swig_callbackOnPan = 0;
2328   swig_callbackOnTap = 0;
2329   swig_callbackOnLongPress = 0;
2330   swig_callbackSignalConnected = 0;
2331   swig_callbackSignalDisconnected = 0;
2332 }
2333
2334 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2335   swig_init_callbacks();
2336 }
2337
2338 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2339
2340 }
2341
2342
2343 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2344   unsigned int c_result = SwigValueInit< unsigned int >() ;
2345   unsigned int jresult = 0 ;
2346
2347   if (!swig_callbackGetNumberOfItems) {
2348     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2349   } else {
2350     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2351     c_result = (unsigned int)jresult;
2352   }
2353   return c_result;
2354 }
2355
2356 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2357   Dali::Actor c_result ;
2358   void * jresult = 0 ;
2359   unsigned int jitemId  ;
2360
2361   if (!swig_callbackNewItem) {
2362     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2363   } else {
2364     jitemId = itemId;
2365     jresult = (void *) swig_callbackNewItem(jitemId);
2366     if (!jresult) {
2367       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2368       return c_result;
2369     }
2370     c_result = *(Dali::Actor *)jresult;
2371   }
2372   return c_result;
2373 }
2374
2375 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2376   unsigned int jitemId  ;
2377   void * jactor  ;
2378
2379   if (!swig_callbackItemReleased) {
2380     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2381     return;
2382   } else {
2383     jitemId = itemId;
2384     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2385     swig_callbackItemReleased(jitemId, jactor);
2386   }
2387 }
2388
2389 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2390   return Dali::Toolkit::ItemFactory::GetExtension();
2391 }
2392
2393 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2394   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2395   swig_callbackNewItem = callbackNewItem;
2396   swig_callbackItemReleased = callbackItemReleased;
2397 }
2398
2399 void SwigDirector_ItemFactory::swig_init_callbacks() {
2400   swig_callbackGetNumberOfItems = 0;
2401   swig_callbackNewItem = 0;
2402   swig_callbackItemReleased = 0;
2403 }
2404
2405 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2406   swig_init_callbacks();
2407 }
2408
2409 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2410
2411 }
2412
2413
2414 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2415   Dali::Actor c_result ;
2416   void * jresult = 0 ;
2417   void * jcurrent  ;
2418   void * jproposed  ;
2419   int jdirection  ;
2420
2421   if (!swig_callbackGetNextFocusableActor) {
2422     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2423   } else {
2424     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2425     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2426     jdirection = (int)direction;
2427     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2428     if (!jresult) {
2429       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2430       return c_result;
2431     }
2432     c_result = *(Dali::Actor *)jresult;
2433   }
2434   return c_result;
2435 }
2436
2437 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2438   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2439 }
2440
2441 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2442   swig_callbackGetNextFocusableActor = 0;
2443 }
2444
2445
2446 #ifdef __cplusplus
2447 extern "C" {
2448 #endif
2449
2450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2451   void * jresult ;
2452   floatp *result = 0 ;
2453
2454   {
2455     try {
2456       result = (floatp *)new_floatp();
2457     } catch (std::out_of_range& e) {
2458       {
2459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2460       };
2461     } catch (std::exception& e) {
2462       {
2463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2464       };
2465     } catch (DaliException e) {
2466       {
2467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2468       };
2469     } catch (...) {
2470       {
2471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2472       };
2473     }
2474   }
2475   jresult = (void *)result;
2476   return jresult;
2477 }
2478
2479
2480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2481   floatp *arg1 = (floatp *) 0 ;
2482
2483   arg1 = (floatp *)jarg1;
2484   {
2485     try {
2486       delete_floatp(arg1);
2487     } catch (std::out_of_range& e) {
2488       {
2489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2490       };
2491     } catch (std::exception& e) {
2492       {
2493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2494       };
2495     } catch (Dali::DaliException e) {
2496       {
2497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2498       };
2499     } catch (...) {
2500       {
2501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2502       };
2503     }
2504   }
2505
2506 }
2507
2508
2509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2510   floatp *arg1 = (floatp *) 0 ;
2511   float arg2 ;
2512
2513   arg1 = (floatp *)jarg1;
2514   arg2 = (float)jarg2;
2515   {
2516     try {
2517       floatp_assign(arg1,arg2);
2518     } catch (std::out_of_range& e) {
2519       {
2520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2521       };
2522     } catch (std::exception& e) {
2523       {
2524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2525       };
2526     } catch (Dali::DaliException e) {
2527       {
2528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2529       };
2530     } catch (...) {
2531       {
2532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2533       };
2534     }
2535   }
2536
2537 }
2538
2539
2540 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2541   float jresult ;
2542   floatp *arg1 = (floatp *) 0 ;
2543   float result;
2544
2545   arg1 = (floatp *)jarg1;
2546   {
2547     try {
2548       result = (float)floatp_value(arg1);
2549     } catch (std::out_of_range& e) {
2550       {
2551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2552       };
2553     } catch (std::exception& e) {
2554       {
2555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2556       };
2557     } catch (DaliException e) {
2558       {
2559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2560       };
2561     } catch (...) {
2562       {
2563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2564       };
2565     }
2566   }
2567   jresult = result;
2568   return jresult;
2569 }
2570
2571
2572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2573   void * jresult ;
2574   floatp *arg1 = (floatp *) 0 ;
2575   float *result = 0 ;
2576
2577   arg1 = (floatp *)jarg1;
2578   {
2579     try {
2580       result = (float *)floatp_cast(arg1);
2581     } catch (std::out_of_range& e) {
2582       {
2583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2584       };
2585     } catch (std::exception& e) {
2586       {
2587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2588       };
2589     } catch (Dali::DaliException e) {
2590       {
2591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2592       };
2593     } catch (...) {
2594       {
2595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2596       };
2597     }
2598   }
2599
2600   jresult = (void *)result;
2601   return jresult;
2602 }
2603
2604
2605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2606   void * jresult ;
2607   float *arg1 = (float *) 0 ;
2608   floatp *result = 0 ;
2609
2610   arg1 = (float *)jarg1;
2611   {
2612     try {
2613       result = (floatp *)floatp_frompointer(arg1);
2614     } catch (std::out_of_range& e) {
2615       {
2616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2617       };
2618     } catch (std::exception& e) {
2619       {
2620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2621       };
2622     } catch (Dali::DaliException e) {
2623       {
2624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2625       };
2626     } catch (...) {
2627       {
2628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2629       };
2630     }
2631   }
2632
2633   jresult = (void *)result;
2634   return jresult;
2635 }
2636
2637
2638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2639   void * jresult ;
2640   intp *result = 0 ;
2641
2642   {
2643     try {
2644       result = (intp *)new_intp();
2645     } catch (std::out_of_range& e) {
2646       {
2647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2648       };
2649     } catch (std::exception& e) {
2650       {
2651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2652       };
2653     } catch (Dali::DaliException e) {
2654       {
2655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2656       };
2657     } catch (...) {
2658       {
2659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2660       };
2661     }
2662   }
2663
2664   jresult = (void *)result;
2665   return jresult;
2666 }
2667
2668
2669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2670   intp *arg1 = (intp *) 0 ;
2671
2672   arg1 = (intp *)jarg1;
2673   {
2674     try {
2675       delete_intp(arg1);
2676     } catch (std::out_of_range& e) {
2677       {
2678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2679       };
2680     } catch (std::exception& e) {
2681       {
2682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2683       };
2684     } catch (Dali::DaliException e) {
2685       {
2686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2687       };
2688     } catch (...) {
2689       {
2690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2691       };
2692     }
2693   }
2694
2695 }
2696
2697
2698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2699   intp *arg1 = (intp *) 0 ;
2700   int arg2 ;
2701
2702   arg1 = (intp *)jarg1;
2703   arg2 = (int)jarg2;
2704   {
2705     try {
2706       intp_assign(arg1,arg2);
2707     } catch (std::out_of_range& e) {
2708       {
2709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2710       };
2711     } catch (std::exception& e) {
2712       {
2713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2714       };
2715     } catch (Dali::DaliException e) {
2716       {
2717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2718       };
2719     } catch (...) {
2720       {
2721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2722       };
2723     }
2724   }
2725
2726 }
2727
2728
2729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2730   int jresult ;
2731   intp *arg1 = (intp *) 0 ;
2732   int result;
2733
2734   arg1 = (intp *)jarg1;
2735   {
2736     try {
2737       result = (int)intp_value(arg1);
2738     } catch (std::out_of_range& e) {
2739       {
2740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2741       };
2742     } catch (std::exception& e) {
2743       {
2744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2745       };
2746     } catch (Dali::DaliException e) {
2747       {
2748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2749       };
2750     } catch (...) {
2751       {
2752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2753       };
2754     }
2755   }
2756
2757   jresult = result;
2758   return jresult;
2759 }
2760
2761
2762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2763   void * jresult ;
2764   intp *arg1 = (intp *) 0 ;
2765   int *result = 0 ;
2766
2767   arg1 = (intp *)jarg1;
2768   {
2769     try {
2770       result = (int *)intp_cast(arg1);
2771     } catch (std::out_of_range& e) {
2772       {
2773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2774       };
2775     } catch (std::exception& e) {
2776       {
2777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2778       };
2779     } catch (Dali::DaliException e) {
2780       {
2781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2782       };
2783     } catch (...) {
2784       {
2785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2786       };
2787     }
2788   }
2789
2790   jresult = (void *)result;
2791   return jresult;
2792 }
2793
2794
2795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2796   void * jresult ;
2797   int *arg1 = (int *) 0 ;
2798   intp *result = 0 ;
2799
2800   arg1 = (int *)jarg1;
2801   {
2802     try {
2803       result = (intp *)intp_frompointer(arg1);
2804     } catch (std::out_of_range& e) {
2805       {
2806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2807       };
2808     } catch (std::exception& e) {
2809       {
2810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2811       };
2812     } catch (Dali::DaliException e) {
2813       {
2814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2815       };
2816     } catch (...) {
2817       {
2818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2819       };
2820     }
2821   }
2822
2823   jresult = (void *)result;
2824   return jresult;
2825 }
2826
2827
2828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2829   void * jresult ;
2830   doublep *result = 0 ;
2831
2832   {
2833     try {
2834       result = (doublep *)new_doublep();
2835     } catch (std::out_of_range& e) {
2836       {
2837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2838       };
2839     } catch (std::exception& e) {
2840       {
2841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2842       };
2843     } catch (Dali::DaliException e) {
2844       {
2845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2846       };
2847     } catch (...) {
2848       {
2849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2850       };
2851     }
2852   }
2853
2854   jresult = (void *)result;
2855   return jresult;
2856 }
2857
2858
2859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2860   doublep *arg1 = (doublep *) 0 ;
2861
2862   arg1 = (doublep *)jarg1;
2863   {
2864     try {
2865       delete_doublep(arg1);
2866     } catch (std::out_of_range& e) {
2867       {
2868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2869       };
2870     } catch (std::exception& e) {
2871       {
2872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2873       };
2874     } catch (Dali::DaliException e) {
2875       {
2876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2877       };
2878     } catch (...) {
2879       {
2880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2881       };
2882     }
2883   }
2884
2885 }
2886
2887
2888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2889   doublep *arg1 = (doublep *) 0 ;
2890   double arg2 ;
2891
2892   arg1 = (doublep *)jarg1;
2893   arg2 = (double)jarg2;
2894   {
2895     try {
2896       doublep_assign(arg1,arg2);
2897     } catch (std::out_of_range& e) {
2898       {
2899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2900       };
2901     } catch (std::exception& e) {
2902       {
2903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2904       };
2905     } catch (Dali::DaliException e) {
2906       {
2907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2908       };
2909     } catch (...) {
2910       {
2911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2912       };
2913     }
2914   }
2915
2916 }
2917
2918
2919 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
2920   double jresult ;
2921   doublep *arg1 = (doublep *) 0 ;
2922   double result;
2923
2924   arg1 = (doublep *)jarg1;
2925   {
2926     try {
2927       result = (double)doublep_value(arg1);
2928     } catch (std::out_of_range& e) {
2929       {
2930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2931       };
2932     } catch (std::exception& e) {
2933       {
2934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2935       };
2936     } catch (Dali::DaliException e) {
2937       {
2938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2939       };
2940     } catch (...) {
2941       {
2942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2943       };
2944     }
2945   }
2946
2947   jresult = result;
2948   return jresult;
2949 }
2950
2951
2952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
2953   void * jresult ;
2954   doublep *arg1 = (doublep *) 0 ;
2955   double *result = 0 ;
2956
2957   arg1 = (doublep *)jarg1;
2958   {
2959     try {
2960       result = (double *)doublep_cast(arg1);
2961     } catch (std::out_of_range& e) {
2962       {
2963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2964       };
2965     } catch (std::exception& e) {
2966       {
2967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2968       };
2969     } catch (Dali::DaliException e) {
2970       {
2971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2972       };
2973     } catch (...) {
2974       {
2975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2976       };
2977     }
2978   }
2979
2980   jresult = (void *)result;
2981   return jresult;
2982 }
2983
2984
2985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
2986   void * jresult ;
2987   double *arg1 = (double *) 0 ;
2988   doublep *result = 0 ;
2989
2990   arg1 = (double *)jarg1;
2991   {
2992     try {
2993       result = (doublep *)doublep_frompointer(arg1);
2994     } catch (std::out_of_range& e) {
2995       {
2996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2997       };
2998     } catch (std::exception& e) {
2999       {
3000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3001       };
3002     } catch (Dali::DaliException e) {
3003       {
3004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3005       };
3006     } catch (...) {
3007       {
3008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3009       };
3010     }
3011   }
3012
3013   jresult = (void *)result;
3014   return jresult;
3015 }
3016
3017
3018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
3019   void * jresult ;
3020   uintp *result = 0 ;
3021
3022   {
3023     try {
3024       result = (uintp *)new_uintp();
3025     } catch (std::out_of_range& e) {
3026       {
3027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3028       };
3029     } catch (std::exception& e) {
3030       {
3031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3032       };
3033     } catch (Dali::DaliException e) {
3034       {
3035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3036       };
3037     } catch (...) {
3038       {
3039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3040       };
3041     }
3042   }
3043
3044   jresult = (void *)result;
3045   return jresult;
3046 }
3047
3048
3049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
3050   uintp *arg1 = (uintp *) 0 ;
3051
3052   arg1 = (uintp *)jarg1;
3053   {
3054     try {
3055       delete_uintp(arg1);
3056     } catch (std::out_of_range& e) {
3057       {
3058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3059       };
3060     } catch (std::exception& e) {
3061       {
3062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3063       };
3064     } catch (Dali::DaliException e) {
3065       {
3066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3067       };
3068     } catch (...) {
3069       {
3070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3071       };
3072     }
3073   }
3074
3075 }
3076
3077
3078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3079   uintp *arg1 = (uintp *) 0 ;
3080   unsigned int arg2 ;
3081
3082   arg1 = (uintp *)jarg1;
3083   arg2 = (unsigned int)jarg2;
3084   {
3085     try {
3086       uintp_assign(arg1,arg2);
3087     } catch (std::out_of_range& e) {
3088       {
3089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3090       };
3091     } catch (std::exception& e) {
3092       {
3093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3094       };
3095     } catch (Dali::DaliException e) {
3096       {
3097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3098       };
3099     } catch (...) {
3100       {
3101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3102       };
3103     }
3104   }
3105
3106 }
3107
3108
3109 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3110   unsigned int jresult ;
3111   uintp *arg1 = (uintp *) 0 ;
3112   unsigned int result;
3113
3114   arg1 = (uintp *)jarg1;
3115   {
3116     try {
3117       result = (unsigned int)uintp_value(arg1);
3118     } catch (std::out_of_range& e) {
3119       {
3120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3121       };
3122     } catch (std::exception& e) {
3123       {
3124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3125       };
3126     } catch (Dali::DaliException e) {
3127       {
3128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3129       };
3130     } catch (...) {
3131       {
3132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3133       };
3134     }
3135   }
3136
3137   jresult = result;
3138   return jresult;
3139 }
3140
3141
3142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3143   void * jresult ;
3144   uintp *arg1 = (uintp *) 0 ;
3145   unsigned int *result = 0 ;
3146
3147   arg1 = (uintp *)jarg1;
3148   {
3149     try {
3150       result = (unsigned int *)uintp_cast(arg1);
3151     } catch (std::out_of_range& e) {
3152       {
3153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3154       };
3155     } catch (std::exception& e) {
3156       {
3157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3158       };
3159     } catch (Dali::DaliException e) {
3160       {
3161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3162       };
3163     } catch (...) {
3164       {
3165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3166       };
3167     }
3168   }
3169
3170   jresult = (void *)result;
3171   return jresult;
3172 }
3173
3174
3175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3176   void * jresult ;
3177   unsigned int *arg1 = (unsigned int *) 0 ;
3178   uintp *result = 0 ;
3179
3180   arg1 = (unsigned int *)jarg1;
3181   {
3182     try {
3183       result = (uintp *)uintp_frompointer(arg1);
3184     } catch (std::out_of_range& e) {
3185       {
3186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3187       };
3188     } catch (std::exception& e) {
3189       {
3190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3191       };
3192     } catch (Dali::DaliException e) {
3193       {
3194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3195       };
3196     } catch (...) {
3197       {
3198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3199       };
3200     }
3201   }
3202
3203   jresult = (void *)result;
3204   return jresult;
3205 }
3206
3207
3208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3209   void * jresult ;
3210   ushortp *result = 0 ;
3211
3212   {
3213     try {
3214       result = (ushortp *)new_ushortp();
3215     } catch (std::out_of_range& e) {
3216       {
3217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3218       };
3219     } catch (std::exception& e) {
3220       {
3221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3222       };
3223     } catch (Dali::DaliException e) {
3224       {
3225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3226       };
3227     } catch (...) {
3228       {
3229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3230       };
3231     }
3232   }
3233
3234   jresult = (void *)result;
3235   return jresult;
3236 }
3237
3238
3239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3240   ushortp *arg1 = (ushortp *) 0 ;
3241
3242   arg1 = (ushortp *)jarg1;
3243   {
3244     try {
3245       delete_ushortp(arg1);
3246     } catch (std::out_of_range& e) {
3247       {
3248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3249       };
3250     } catch (std::exception& e) {
3251       {
3252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3253       };
3254     } catch (Dali::DaliException e) {
3255       {
3256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3257       };
3258     } catch (...) {
3259       {
3260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3261       };
3262     }
3263   }
3264
3265 }
3266
3267
3268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3269   ushortp *arg1 = (ushortp *) 0 ;
3270   unsigned short arg2 ;
3271
3272   arg1 = (ushortp *)jarg1;
3273   arg2 = (unsigned short)jarg2;
3274   {
3275     try {
3276       ushortp_assign(arg1,arg2);
3277     } catch (std::out_of_range& e) {
3278       {
3279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3280       };
3281     } catch (std::exception& e) {
3282       {
3283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3284       };
3285     } catch (Dali::DaliException e) {
3286       {
3287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3288       };
3289     } catch (...) {
3290       {
3291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3292       };
3293     }
3294   }
3295
3296 }
3297
3298
3299 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3300   unsigned short jresult ;
3301   ushortp *arg1 = (ushortp *) 0 ;
3302   unsigned short result;
3303
3304   arg1 = (ushortp *)jarg1;
3305   {
3306     try {
3307       result = (unsigned short)ushortp_value(arg1);
3308     } catch (std::out_of_range& e) {
3309       {
3310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3311       };
3312     } catch (std::exception& e) {
3313       {
3314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3315       };
3316     } catch (Dali::DaliException e) {
3317       {
3318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3319       };
3320     } catch (...) {
3321       {
3322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3323       };
3324     }
3325   }
3326
3327   jresult = result;
3328   return jresult;
3329 }
3330
3331
3332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3333   void * jresult ;
3334   ushortp *arg1 = (ushortp *) 0 ;
3335   unsigned short *result = 0 ;
3336
3337   arg1 = (ushortp *)jarg1;
3338   {
3339     try {
3340       result = (unsigned short *)ushortp_cast(arg1);
3341     } catch (std::out_of_range& e) {
3342       {
3343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3344       };
3345     } catch (std::exception& e) {
3346       {
3347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3348       };
3349     } catch (Dali::DaliException e) {
3350       {
3351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3352       };
3353     } catch (...) {
3354       {
3355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3356       };
3357     }
3358   }
3359
3360   jresult = (void *)result;
3361   return jresult;
3362 }
3363
3364
3365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3366   void * jresult ;
3367   unsigned short *arg1 = (unsigned short *) 0 ;
3368   ushortp *result = 0 ;
3369
3370   arg1 = (unsigned short *)jarg1;
3371   {
3372     try {
3373       result = (ushortp *)ushortp_frompointer(arg1);
3374     } catch (std::out_of_range& e) {
3375       {
3376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3377       };
3378     } catch (std::exception& e) {
3379       {
3380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3381       };
3382     } catch (Dali::DaliException e) {
3383       {
3384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3385       };
3386     } catch (...) {
3387       {
3388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3389       };
3390     }
3391   }
3392
3393   jresult = (void *)result;
3394   return jresult;
3395 }
3396
3397
3398 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3399   unsigned int jresult ;
3400   int arg1 ;
3401   unsigned int result;
3402
3403   arg1 = (int)jarg1;
3404   {
3405     try {
3406       result = (unsigned int)int_to_uint(arg1);
3407     } catch (std::out_of_range& e) {
3408       {
3409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3410       };
3411     } catch (std::exception& e) {
3412       {
3413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3414       };
3415     } catch (Dali::DaliException e) {
3416       {
3417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3418       };
3419     } catch (...) {
3420       {
3421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3422       };
3423     }
3424   }
3425
3426   jresult = result;
3427   return jresult;
3428 }
3429
3430
3431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3432   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3433
3434   arg1 = (Dali::RefObject *)jarg1;
3435   {
3436     try {
3437       (arg1)->Reference();
3438     } catch (std::out_of_range& e) {
3439       {
3440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3441       };
3442     } catch (std::exception& e) {
3443       {
3444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3445       };
3446     } catch (Dali::DaliException e) {
3447       {
3448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3449       };
3450     } catch (...) {
3451       {
3452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3453       };
3454     }
3455   }
3456
3457 }
3458
3459
3460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3461   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3462
3463   arg1 = (Dali::RefObject *)jarg1;
3464   {
3465     try {
3466       (arg1)->Unreference();
3467     } catch (std::out_of_range& e) {
3468       {
3469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3470       };
3471     } catch (std::exception& e) {
3472       {
3473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3474       };
3475     } catch (Dali::DaliException e) {
3476       {
3477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3478       };
3479     } catch (...) {
3480       {
3481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3482       };
3483     }
3484   }
3485
3486 }
3487
3488
3489 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3490   int jresult ;
3491   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3492   int result;
3493
3494   arg1 = (Dali::RefObject *)jarg1;
3495   {
3496     try {
3497       result = (int)(arg1)->ReferenceCount();
3498     } catch (std::out_of_range& e) {
3499       {
3500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3501       };
3502     } catch (std::exception& e) {
3503       {
3504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3505       };
3506     } catch (Dali::DaliException e) {
3507       {
3508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3509       };
3510     } catch (...) {
3511       {
3512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3513       };
3514     }
3515   }
3516
3517   jresult = result;
3518   return jresult;
3519 }
3520
3521
3522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3523   void * jresult ;
3524   Dali::Any *result = 0 ;
3525
3526   {
3527     try {
3528       result = (Dali::Any *)new Dali::Any();
3529     } catch (std::out_of_range& e) {
3530       {
3531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3532       };
3533     } catch (std::exception& e) {
3534       {
3535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3536       };
3537     } catch (Dali::DaliException e) {
3538       {
3539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3540       };
3541     } catch (...) {
3542       {
3543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3544       };
3545     }
3546   }
3547
3548   jresult = (void *)result;
3549   return jresult;
3550 }
3551
3552
3553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3554   Dali::Any *arg1 = (Dali::Any *) 0 ;
3555
3556   arg1 = (Dali::Any *)jarg1;
3557   {
3558     try {
3559       delete arg1;
3560     } catch (std::out_of_range& e) {
3561       {
3562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3563       };
3564     } catch (std::exception& e) {
3565       {
3566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3567       };
3568     } catch (Dali::DaliException e) {
3569       {
3570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3571       };
3572     } catch (...) {
3573       {
3574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3575       };
3576     }
3577   }
3578
3579 }
3580
3581
3582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3583   char *arg1 = (char *) 0 ;
3584
3585   arg1 = (char *)jarg1;
3586   {
3587     try {
3588       Dali::Any::AssertAlways((char const *)arg1);
3589     } catch (std::out_of_range& e) {
3590       {
3591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3592       };
3593     } catch (std::exception& e) {
3594       {
3595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3596       };
3597     } catch (Dali::DaliException e) {
3598       {
3599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3600       };
3601     } catch (...) {
3602       {
3603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3604       };
3605     }
3606   }
3607
3608 }
3609
3610
3611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3612   void * jresult ;
3613   Dali::Any *arg1 = 0 ;
3614   Dali::Any *result = 0 ;
3615
3616   arg1 = (Dali::Any *)jarg1;
3617   if (!arg1) {
3618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3619     return 0;
3620   }
3621   {
3622     try {
3623       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3624     } catch (std::out_of_range& e) {
3625       {
3626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3627       };
3628     } catch (std::exception& e) {
3629       {
3630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3631       };
3632     } catch (Dali::DaliException e) {
3633       {
3634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3635       };
3636     } catch (...) {
3637       {
3638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3639       };
3640     }
3641   }
3642
3643   jresult = (void *)result;
3644   return jresult;
3645 }
3646
3647
3648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3649   void * jresult ;
3650   Dali::Any *arg1 = (Dali::Any *) 0 ;
3651   Dali::Any *arg2 = 0 ;
3652   Dali::Any *result = 0 ;
3653
3654   arg1 = (Dali::Any *)jarg1;
3655   arg2 = (Dali::Any *)jarg2;
3656   if (!arg2) {
3657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3658     return 0;
3659   }
3660   {
3661     try {
3662       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3663     } catch (std::out_of_range& e) {
3664       {
3665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3666       };
3667     } catch (std::exception& e) {
3668       {
3669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3670       };
3671     } catch (Dali::DaliException e) {
3672       {
3673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3674       };
3675     } catch (...) {
3676       {
3677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3678       };
3679     }
3680   }
3681
3682   jresult = (void *)result;
3683   return jresult;
3684 }
3685
3686
3687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3688   void * jresult ;
3689   Dali::Any *arg1 = (Dali::Any *) 0 ;
3690   std::type_info *result = 0 ;
3691
3692   arg1 = (Dali::Any *)jarg1;
3693   {
3694     try {
3695       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3696     } catch (std::out_of_range& e) {
3697       {
3698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3699       };
3700     } catch (std::exception& e) {
3701       {
3702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3703       };
3704     } catch (Dali::DaliException e) {
3705       {
3706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3707       };
3708     } catch (...) {
3709       {
3710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3711       };
3712     }
3713   }
3714
3715   jresult = (void *)result;
3716   return jresult;
3717 }
3718
3719
3720 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3721   unsigned int jresult ;
3722   Dali::Any *arg1 = (Dali::Any *) 0 ;
3723   bool result;
3724
3725   arg1 = (Dali::Any *)jarg1;
3726   {
3727     try {
3728       result = (bool)((Dali::Any const *)arg1)->Empty();
3729     } catch (std::out_of_range& e) {
3730       {
3731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3732       };
3733     } catch (std::exception& e) {
3734       {
3735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3736       };
3737     } catch (Dali::DaliException e) {
3738       {
3739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3740       };
3741     } catch (...) {
3742       {
3743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3744       };
3745     }
3746   }
3747
3748   jresult = result;
3749   return jresult;
3750 }
3751
3752
3753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3754   void * jresult ;
3755   std::type_info *arg1 = 0 ;
3756   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3757   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3758   Dali::Any::AnyContainerBase *result = 0 ;
3759
3760   arg1 = (std::type_info *)jarg1;
3761   if (!arg1) {
3762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3763     return 0;
3764   }
3765   arg2 = (Dali::Any::CloneFunc)jarg2;
3766   arg3 = (Dali::Any::DeleteFunc)jarg3;
3767   {
3768     try {
3769       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3770     } catch (std::out_of_range& e) {
3771       {
3772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3773       };
3774     } catch (std::exception& e) {
3775       {
3776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3777       };
3778     } catch (Dali::DaliException e) {
3779       {
3780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3781       };
3782     } catch (...) {
3783       {
3784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3785       };
3786     }
3787   }
3788
3789   jresult = (void *)result;
3790   return jresult;
3791 }
3792
3793
3794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3795   void * jresult ;
3796   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3797   std::type_info *result = 0 ;
3798
3799   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3800   {
3801     try {
3802       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3803     } catch (std::out_of_range& e) {
3804       {
3805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3806       };
3807     } catch (std::exception& e) {
3808       {
3809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3810       };
3811     } catch (Dali::DaliException e) {
3812       {
3813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3814       };
3815     } catch (...) {
3816       {
3817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3818       };
3819     }
3820   }
3821
3822   jresult = (void *)result;
3823   return jresult;
3824 }
3825
3826
3827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3828   void * jresult ;
3829   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3830   ::std::type_info *result = 0 ;
3831
3832   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3833   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3834   jresult = (void *)result;
3835   return jresult;
3836 }
3837
3838
3839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3840   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3841   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3842
3843   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3844   arg2 = (Dali::Any::CloneFunc)jarg2;
3845   if (arg1) (arg1)->mCloneFunc = arg2;
3846 }
3847
3848
3849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3850   void * jresult ;
3851   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3852   Dali::Any::CloneFunc result;
3853
3854   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3855   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3856   jresult = (void *)result;
3857   return jresult;
3858 }
3859
3860
3861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3862   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3863   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3864
3865   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3866   arg2 = (Dali::Any::DeleteFunc)jarg2;
3867   if (arg1) (arg1)->mDeleteFunc = arg2;
3868 }
3869
3870
3871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
3872   void * jresult ;
3873   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3874   Dali::Any::DeleteFunc result;
3875
3876   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3877   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
3878   jresult = (void *)result;
3879   return jresult;
3880 }
3881
3882
3883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
3884   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3885
3886   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3887   {
3888     try {
3889       delete arg1;
3890     } catch (std::out_of_range& e) {
3891       {
3892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3893       };
3894     } catch (std::exception& e) {
3895       {
3896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3897       };
3898     } catch (Dali::DaliException e) {
3899       {
3900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3901       };
3902     } catch (...) {
3903       {
3904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3905       };
3906     }
3907   }
3908
3909 }
3910
3911
3912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
3913   Dali::Any *arg1 = (Dali::Any *) 0 ;
3914   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
3915
3916   arg1 = (Dali::Any *)jarg1;
3917   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
3918   if (arg1) (arg1)->mContainer = arg2;
3919 }
3920
3921
3922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
3923   void * jresult ;
3924   Dali::Any *arg1 = (Dali::Any *) 0 ;
3925   Dali::Any::AnyContainerBase *result = 0 ;
3926
3927   arg1 = (Dali::Any *)jarg1;
3928   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
3929   jresult = (void *)result;
3930   return jresult;
3931 }
3932
3933
3934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
3935   char *arg1 = (char *) 0 ;
3936   char *arg2 = (char *) 0 ;
3937
3938   arg1 = (char *)jarg1;
3939   arg2 = (char *)jarg2;
3940   {
3941     try {
3942       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
3943     } catch (std::out_of_range& e) {
3944       {
3945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3946       };
3947     } catch (std::exception& e) {
3948       {
3949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3950       };
3951     } catch (Dali::DaliException e) {
3952       {
3953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3954       };
3955     } catch (...) {
3956       {
3957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3958       };
3959     }
3960   }
3961
3962 }
3963
3964
3965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
3966   void * jresult ;
3967   char *arg1 = (char *) 0 ;
3968   char *arg2 = (char *) 0 ;
3969   Dali::DaliException *result = 0 ;
3970
3971   arg1 = (char *)jarg1;
3972   arg2 = (char *)jarg2;
3973   {
3974     try {
3975       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
3976     } catch (std::out_of_range& e) {
3977       {
3978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3979       };
3980     } catch (std::exception& e) {
3981       {
3982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3983       };
3984     } catch (Dali::DaliException e) {
3985       {
3986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3987       };
3988     } catch (...) {
3989       {
3990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3991       };
3992     }
3993   }
3994
3995   jresult = (void *)result;
3996   return jresult;
3997 }
3998
3999
4000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
4001   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4002   std::string arg2 = std::string(jarg2);
4003
4004   arg1 = (Dali::DaliException *)jarg1;
4005   {
4006     if (!arg2.empty()) {
4007       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
4008     } else {
4009       arg1->location = 0;
4010     }
4011   }
4012 }
4013
4014 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
4015   char * jresult ;
4016   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4017   char *result = 0 ;
4018
4019   arg1 = (Dali::DaliException *)jarg1;
4020   result = (char *) ((arg1)->location);
4021   jresult = SWIG_csharp_string_callback((const char *)result);
4022   return jresult;
4023 }
4024
4025
4026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
4027   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4028   std::string arg2 = std::string(jarg2);
4029
4030   arg1 = (Dali::DaliException *)jarg1;
4031   {
4032     if (!arg2.empty()) {
4033       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
4034     } else {
4035       arg1->condition = 0;
4036     }
4037   }
4038 }
4039
4040
4041 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
4042   char * jresult ;
4043   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4044   char *result = 0 ;
4045
4046   arg1 = (Dali::DaliException *)jarg1;
4047   result = (char *) ((arg1)->condition);
4048   jresult = SWIG_csharp_string_callback((const char *)result);
4049   return jresult;
4050 }
4051
4052
4053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
4054   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4055
4056   arg1 = (Dali::DaliException *)jarg1;
4057   {
4058     try {
4059       delete arg1;
4060     } catch (std::out_of_range& e) {
4061       {
4062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4063       };
4064     } catch (std::exception& e) {
4065       {
4066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4067       };
4068     } catch (Dali::DaliException e) {
4069       {
4070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4071       };
4072     } catch (...) {
4073       {
4074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4075       };
4076     }
4077   }
4078
4079 }
4080
4081
4082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
4083   void * jresult ;
4084   Dali::Vector2 *result = 0 ;
4085
4086   {
4087     try {
4088       result = (Dali::Vector2 *)new Dali::Vector2();
4089     } catch (std::out_of_range& e) {
4090       {
4091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4092       };
4093     } catch (std::exception& e) {
4094       {
4095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4096       };
4097     } catch (Dali::DaliException e) {
4098       {
4099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4100       };
4101     } catch (...) {
4102       {
4103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4104       };
4105     }
4106   }
4107
4108   jresult = (void *)result;
4109   return jresult;
4110 }
4111
4112
4113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
4114   void * jresult ;
4115   float arg1 ;
4116   float arg2 ;
4117   Dali::Vector2 *result = 0 ;
4118
4119   arg1 = (float)jarg1;
4120   arg2 = (float)jarg2;
4121   {
4122     try {
4123       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
4124     } catch (std::out_of_range& e) {
4125       {
4126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4127       };
4128     } catch (std::exception& e) {
4129       {
4130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4131       };
4132     } catch (Dali::DaliException e) {
4133       {
4134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4135       };
4136     } catch (...) {
4137       {
4138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4139       };
4140     }
4141   }
4142
4143   jresult = (void *)result;
4144   return jresult;
4145 }
4146
4147
4148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
4149   void * jresult ;
4150   float *arg1 = (float *) 0 ;
4151   Dali::Vector2 *result = 0 ;
4152
4153   arg1 = jarg1;
4154   {
4155     try {
4156       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
4157     } catch (std::out_of_range& e) {
4158       {
4159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4160       };
4161     } catch (std::exception& e) {
4162       {
4163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4164       };
4165     } catch (Dali::DaliException e) {
4166       {
4167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4168       };
4169     } catch (...) {
4170       {
4171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4172       };
4173     }
4174   }
4175
4176   jresult = (void *)result;
4177
4178
4179   return jresult;
4180 }
4181
4182
4183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
4184   void * jresult ;
4185   Dali::Vector3 *arg1 = 0 ;
4186   Dali::Vector2 *result = 0 ;
4187
4188   arg1 = (Dali::Vector3 *)jarg1;
4189   if (!arg1) {
4190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4191     return 0;
4192   }
4193   {
4194     try {
4195       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
4196     } catch (std::out_of_range& e) {
4197       {
4198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4199       };
4200     } catch (std::exception& e) {
4201       {
4202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4203       };
4204     } catch (Dali::DaliException e) {
4205       {
4206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4207       };
4208     } catch (...) {
4209       {
4210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4211       };
4212     }
4213   }
4214
4215   jresult = (void *)result;
4216   return jresult;
4217 }
4218
4219
4220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4221   void * jresult ;
4222   Dali::Vector4 *arg1 = 0 ;
4223   Dali::Vector2 *result = 0 ;
4224
4225   arg1 = (Dali::Vector4 *)jarg1;
4226   if (!arg1) {
4227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4228     return 0;
4229   }
4230   {
4231     try {
4232       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4233     } catch (std::out_of_range& e) {
4234       {
4235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4236       };
4237     } catch (std::exception& e) {
4238       {
4239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4240       };
4241     } catch (Dali::DaliException e) {
4242       {
4243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4244       };
4245     } catch (...) {
4246       {
4247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4248       };
4249     }
4250   }
4251
4252   jresult = (void *)result;
4253   return jresult;
4254 }
4255
4256
4257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4258   void * jresult ;
4259   Dali::Vector2 *result = 0 ;
4260
4261   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4262   jresult = (void *)result;
4263   return jresult;
4264 }
4265
4266
4267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4268   void * jresult ;
4269   Dali::Vector2 *result = 0 ;
4270
4271   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4272   jresult = (void *)result;
4273   return jresult;
4274 }
4275
4276
4277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4278   void * jresult ;
4279   Dali::Vector2 *result = 0 ;
4280
4281   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4282   jresult = (void *)result;
4283   return jresult;
4284 }
4285
4286
4287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4288   void * jresult ;
4289   Dali::Vector2 *result = 0 ;
4290
4291   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4292   jresult = (void *)result;
4293   return jresult;
4294 }
4295
4296
4297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4298   void * jresult ;
4299   Dali::Vector2 *result = 0 ;
4300
4301   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4302   jresult = (void *)result;
4303   return jresult;
4304 }
4305
4306
4307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4308   void * jresult ;
4309   Dali::Vector2 *result = 0 ;
4310
4311   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4312   jresult = (void *)result;
4313   return jresult;
4314 }
4315
4316
4317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4318   void * jresult ;
4319   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4320   float *arg2 = (float *) 0 ;
4321   Dali::Vector2 *result = 0 ;
4322
4323   arg1 = (Dali::Vector2 *)jarg1;
4324   arg2 = jarg2;
4325   {
4326     try {
4327       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4328     } catch (std::out_of_range& e) {
4329       {
4330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4331       };
4332     } catch (std::exception& e) {
4333       {
4334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4335       };
4336     } catch (Dali::DaliException e) {
4337       {
4338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4339       };
4340     } catch (...) {
4341       {
4342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4343       };
4344     }
4345   }
4346
4347   jresult = (void *)result;
4348
4349
4350   return jresult;
4351 }
4352
4353
4354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4355   void * jresult ;
4356   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4357   Dali::Vector3 *arg2 = 0 ;
4358   Dali::Vector2 *result = 0 ;
4359
4360   arg1 = (Dali::Vector2 *)jarg1;
4361   arg2 = (Dali::Vector3 *)jarg2;
4362   if (!arg2) {
4363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4364     return 0;
4365   }
4366   {
4367     try {
4368       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4369     } catch (std::out_of_range& e) {
4370       {
4371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4372       };
4373     } catch (std::exception& e) {
4374       {
4375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4376       };
4377     } catch (Dali::DaliException e) {
4378       {
4379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4380       };
4381     } catch (...) {
4382       {
4383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4384       };
4385     }
4386   }
4387
4388   jresult = (void *)result;
4389   return jresult;
4390 }
4391
4392
4393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4394   void * jresult ;
4395   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4396   Dali::Vector4 *arg2 = 0 ;
4397   Dali::Vector2 *result = 0 ;
4398
4399   arg1 = (Dali::Vector2 *)jarg1;
4400   arg2 = (Dali::Vector4 *)jarg2;
4401   if (!arg2) {
4402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4403     return 0;
4404   }
4405   {
4406     try {
4407       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4408     } catch (std::out_of_range& e) {
4409       {
4410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4411       };
4412     } catch (std::exception& e) {
4413       {
4414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4415       };
4416     } catch (Dali::DaliException e) {
4417       {
4418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4419       };
4420     } catch (...) {
4421       {
4422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4423       };
4424     }
4425   }
4426
4427   jresult = (void *)result;
4428   return jresult;
4429 }
4430
4431
4432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4433   void * jresult ;
4434   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4435   Dali::Vector2 *arg2 = 0 ;
4436   Dali::Vector2 result;
4437
4438   arg1 = (Dali::Vector2 *)jarg1;
4439   arg2 = (Dali::Vector2 *)jarg2;
4440   if (!arg2) {
4441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4442     return 0;
4443   }
4444   {
4445     try {
4446       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4447     } catch (std::out_of_range& e) {
4448       {
4449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4450       };
4451     } catch (std::exception& e) {
4452       {
4453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4454       };
4455     } catch (Dali::DaliException e) {
4456       {
4457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4458       };
4459     } catch (...) {
4460       {
4461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4462       };
4463     }
4464   }
4465
4466   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4467   return jresult;
4468 }
4469
4470
4471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4472   void * jresult ;
4473   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4474   Dali::Vector2 *arg2 = 0 ;
4475   Dali::Vector2 *result = 0 ;
4476
4477   arg1 = (Dali::Vector2 *)jarg1;
4478   arg2 = (Dali::Vector2 *)jarg2;
4479   if (!arg2) {
4480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4481     return 0;
4482   }
4483   {
4484     try {
4485       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4486     } catch (std::out_of_range& e) {
4487       {
4488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4489       };
4490     } catch (std::exception& e) {
4491       {
4492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4493       };
4494     } catch (Dali::DaliException e) {
4495       {
4496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4497       };
4498     } catch (...) {
4499       {
4500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4501       };
4502     }
4503   }
4504
4505   jresult = (void *)result;
4506   return jresult;
4507 }
4508
4509
4510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4511   void * jresult ;
4512   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4513   Dali::Vector2 *arg2 = 0 ;
4514   Dali::Vector2 result;
4515
4516   arg1 = (Dali::Vector2 *)jarg1;
4517   arg2 = (Dali::Vector2 *)jarg2;
4518   if (!arg2) {
4519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4520     return 0;
4521   }
4522   {
4523     try {
4524       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4525     } catch (std::out_of_range& e) {
4526       {
4527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4528       };
4529     } catch (std::exception& e) {
4530       {
4531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4532       };
4533     } catch (Dali::DaliException e) {
4534       {
4535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4536       };
4537     } catch (...) {
4538       {
4539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4540       };
4541     }
4542   }
4543
4544   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4545   return jresult;
4546 }
4547
4548
4549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4550   void * jresult ;
4551   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4552   Dali::Vector2 *arg2 = 0 ;
4553   Dali::Vector2 *result = 0 ;
4554
4555   arg1 = (Dali::Vector2 *)jarg1;
4556   arg2 = (Dali::Vector2 *)jarg2;
4557   if (!arg2) {
4558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4559     return 0;
4560   }
4561   {
4562     try {
4563       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4564     } catch (std::out_of_range& e) {
4565       {
4566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4567       };
4568     } catch (std::exception& e) {
4569       {
4570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4571       };
4572     } catch (Dali::DaliException e) {
4573       {
4574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4575       };
4576     } catch (...) {
4577       {
4578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4579       };
4580     }
4581   }
4582
4583   jresult = (void *)result;
4584   return jresult;
4585 }
4586
4587
4588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4589   void * jresult ;
4590   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4591   Dali::Vector2 *arg2 = 0 ;
4592   Dali::Vector2 result;
4593
4594   arg1 = (Dali::Vector2 *)jarg1;
4595   arg2 = (Dali::Vector2 *)jarg2;
4596   if (!arg2) {
4597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4598     return 0;
4599   }
4600   {
4601     try {
4602       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4603     } catch (std::out_of_range& e) {
4604       {
4605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4606       };
4607     } catch (std::exception& e) {
4608       {
4609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4610       };
4611     } catch (Dali::DaliException e) {
4612       {
4613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4614       };
4615     } catch (...) {
4616       {
4617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4618       };
4619     }
4620   }
4621
4622   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4623   return jresult;
4624 }
4625
4626
4627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4628   void * jresult ;
4629   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4630   float arg2 ;
4631   Dali::Vector2 result;
4632
4633   arg1 = (Dali::Vector2 *)jarg1;
4634   arg2 = (float)jarg2;
4635   {
4636     try {
4637       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4638     } catch (std::out_of_range& e) {
4639       {
4640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4641       };
4642     } catch (std::exception& e) {
4643       {
4644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4645       };
4646     } catch (Dali::DaliException e) {
4647       {
4648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4649       };
4650     } catch (...) {
4651       {
4652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4653       };
4654     }
4655   }
4656
4657   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4658   return jresult;
4659 }
4660
4661
4662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4663   void * jresult ;
4664   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4665   Dali::Vector2 *arg2 = 0 ;
4666   Dali::Vector2 *result = 0 ;
4667
4668   arg1 = (Dali::Vector2 *)jarg1;
4669   arg2 = (Dali::Vector2 *)jarg2;
4670   if (!arg2) {
4671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4672     return 0;
4673   }
4674   {
4675     try {
4676       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4677     } catch (std::out_of_range& e) {
4678       {
4679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4680       };
4681     } catch (std::exception& e) {
4682       {
4683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4684       };
4685     } catch (Dali::DaliException e) {
4686       {
4687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4688       };
4689     } catch (...) {
4690       {
4691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4692       };
4693     }
4694   }
4695
4696   jresult = (void *)result;
4697   return jresult;
4698 }
4699
4700
4701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4702   void * jresult ;
4703   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4704   float arg2 ;
4705   Dali::Vector2 *result = 0 ;
4706
4707   arg1 = (Dali::Vector2 *)jarg1;
4708   arg2 = (float)jarg2;
4709   {
4710     try {
4711       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4712     } catch (std::out_of_range& e) {
4713       {
4714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4715       };
4716     } catch (std::exception& e) {
4717       {
4718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4719       };
4720     } catch (Dali::DaliException e) {
4721       {
4722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4723       };
4724     } catch (...) {
4725       {
4726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4727       };
4728     }
4729   }
4730
4731   jresult = (void *)result;
4732   return jresult;
4733 }
4734
4735
4736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4737   void * jresult ;
4738   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4739   Dali::Vector2 *arg2 = 0 ;
4740   Dali::Vector2 result;
4741
4742   arg1 = (Dali::Vector2 *)jarg1;
4743   arg2 = (Dali::Vector2 *)jarg2;
4744   if (!arg2) {
4745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4746     return 0;
4747   }
4748   {
4749     try {
4750       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4751     } catch (std::out_of_range& e) {
4752       {
4753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4754       };
4755     } catch (std::exception& e) {
4756       {
4757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4758       };
4759     } catch (Dali::DaliException e) {
4760       {
4761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4762       };
4763     } catch (...) {
4764       {
4765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4766       };
4767     }
4768   }
4769
4770   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4771   return jresult;
4772 }
4773
4774
4775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4776   void * jresult ;
4777   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4778   float arg2 ;
4779   Dali::Vector2 result;
4780
4781   arg1 = (Dali::Vector2 *)jarg1;
4782   arg2 = (float)jarg2;
4783   {
4784     try {
4785       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4786     } catch (std::out_of_range& e) {
4787       {
4788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4789       };
4790     } catch (std::exception& e) {
4791       {
4792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4793       };
4794     } catch (Dali::DaliException e) {
4795       {
4796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4797       };
4798     } catch (...) {
4799       {
4800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4801       };
4802     }
4803   }
4804
4805   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4806   return jresult;
4807 }
4808
4809
4810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4811   void * jresult ;
4812   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4813   Dali::Vector2 *arg2 = 0 ;
4814   Dali::Vector2 *result = 0 ;
4815
4816   arg1 = (Dali::Vector2 *)jarg1;
4817   arg2 = (Dali::Vector2 *)jarg2;
4818   if (!arg2) {
4819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4820     return 0;
4821   }
4822   {
4823     try {
4824       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4825     } catch (std::out_of_range& e) {
4826       {
4827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4828       };
4829     } catch (std::exception& e) {
4830       {
4831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4832       };
4833     } catch (Dali::DaliException e) {
4834       {
4835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4836       };
4837     } catch (...) {
4838       {
4839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4840       };
4841     }
4842   }
4843
4844   jresult = (void *)result;
4845   return jresult;
4846 }
4847
4848
4849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4850   void * jresult ;
4851   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4852   float arg2 ;
4853   Dali::Vector2 *result = 0 ;
4854
4855   arg1 = (Dali::Vector2 *)jarg1;
4856   arg2 = (float)jarg2;
4857   {
4858     try {
4859       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4860     } catch (std::out_of_range& e) {
4861       {
4862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4863       };
4864     } catch (std::exception& e) {
4865       {
4866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4867       };
4868     } catch (Dali::DaliException e) {
4869       {
4870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4871       };
4872     } catch (...) {
4873       {
4874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4875       };
4876     }
4877   }
4878
4879   jresult = (void *)result;
4880   return jresult;
4881 }
4882
4883
4884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
4885   void * jresult ;
4886   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4887   Dali::Vector2 result;
4888
4889   arg1 = (Dali::Vector2 *)jarg1;
4890   {
4891     try {
4892       result = ((Dali::Vector2 const *)arg1)->operator -();
4893     } catch (std::out_of_range& e) {
4894       {
4895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4896       };
4897     } catch (std::exception& e) {
4898       {
4899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4900       };
4901     } catch (Dali::DaliException e) {
4902       {
4903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4904       };
4905     } catch (...) {
4906       {
4907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4908       };
4909     }
4910   }
4911
4912   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4913   return jresult;
4914 }
4915
4916
4917 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
4918   unsigned int jresult ;
4919   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4920   Dali::Vector2 *arg2 = 0 ;
4921   bool result;
4922
4923   arg1 = (Dali::Vector2 *)jarg1;
4924   arg2 = (Dali::Vector2 *)jarg2;
4925   if (!arg2) {
4926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4927     return 0;
4928   }
4929   {
4930     try {
4931       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
4932     } catch (std::out_of_range& e) {
4933       {
4934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4935       };
4936     } catch (std::exception& e) {
4937       {
4938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4939       };
4940     } catch (Dali::DaliException e) {
4941       {
4942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4943       };
4944     } catch (...) {
4945       {
4946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4947       };
4948     }
4949   }
4950
4951   jresult = result;
4952   return jresult;
4953 }
4954
4955
4956 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
4957   unsigned int jresult ;
4958   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4959   Dali::Vector2 *arg2 = 0 ;
4960   bool result;
4961
4962   arg1 = (Dali::Vector2 *)jarg1;
4963   arg2 = (Dali::Vector2 *)jarg2;
4964   if (!arg2) {
4965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4966     return 0;
4967   }
4968   {
4969     try {
4970       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
4971     } catch (std::out_of_range& e) {
4972       {
4973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4974       };
4975     } catch (std::exception& e) {
4976       {
4977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4978       };
4979     } catch (Dali::DaliException e) {
4980       {
4981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4982       };
4983     } catch (...) {
4984       {
4985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4986       };
4987     }
4988   }
4989
4990   jresult = result;
4991   return jresult;
4992 }
4993
4994
4995 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
4996   float jresult ;
4997   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4998   unsigned int arg2 ;
4999   float *result = 0 ;
5000
5001   arg1 = (Dali::Vector2 *)jarg1;
5002   arg2 = (unsigned int)jarg2;
5003   {
5004     try {
5005       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
5006     } catch (std::out_of_range& e) {
5007       {
5008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5009       };
5010     } catch (std::exception& e) {
5011       {
5012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5013       };
5014     } catch (Dali::DaliException e) {
5015       {
5016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5017       };
5018     } catch (...) {
5019       {
5020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5021       };
5022     }
5023   }
5024
5025   jresult = *result;
5026   return jresult;
5027 }
5028
5029
5030 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
5031   float jresult ;
5032   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5033   float result;
5034
5035   arg1 = (Dali::Vector2 *)jarg1;
5036   {
5037     try {
5038       result = (float)((Dali::Vector2 const *)arg1)->Length();
5039     } catch (std::out_of_range& e) {
5040       {
5041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5042       };
5043     } catch (std::exception& e) {
5044       {
5045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5046       };
5047     } catch (Dali::DaliException e) {
5048       {
5049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5050       };
5051     } catch (...) {
5052       {
5053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5054       };
5055     }
5056   }
5057
5058   jresult = result;
5059   return jresult;
5060 }
5061
5062
5063 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
5064   float jresult ;
5065   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5066   float result;
5067
5068   arg1 = (Dali::Vector2 *)jarg1;
5069   {
5070     try {
5071       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
5072     } catch (std::out_of_range& e) {
5073       {
5074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5075       };
5076     } catch (std::exception& e) {
5077       {
5078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5079       };
5080     } catch (Dali::DaliException e) {
5081       {
5082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5083       };
5084     } catch (...) {
5085       {
5086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5087       };
5088     }
5089   }
5090
5091   jresult = result;
5092   return jresult;
5093 }
5094
5095
5096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
5097   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5098
5099   arg1 = (Dali::Vector2 *)jarg1;
5100   {
5101     try {
5102       (arg1)->Normalize();
5103     } catch (std::out_of_range& e) {
5104       {
5105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5106       };
5107     } catch (std::exception& e) {
5108       {
5109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5110       };
5111     } catch (Dali::DaliException e) {
5112       {
5113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5114       };
5115     } catch (...) {
5116       {
5117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5118       };
5119     }
5120   }
5121
5122 }
5123
5124
5125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5126   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5127   Dali::Vector2 *arg2 = 0 ;
5128   Dali::Vector2 *arg3 = 0 ;
5129
5130   arg1 = (Dali::Vector2 *)jarg1;
5131   arg2 = (Dali::Vector2 *)jarg2;
5132   if (!arg2) {
5133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5134     return ;
5135   }
5136   arg3 = (Dali::Vector2 *)jarg3;
5137   if (!arg3) {
5138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5139     return ;
5140   }
5141   {
5142     try {
5143       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
5144     } catch (std::out_of_range& e) {
5145       {
5146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5147       };
5148     } catch (std::exception& e) {
5149       {
5150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5151       };
5152     } catch (Dali::DaliException e) {
5153       {
5154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5155       };
5156     } catch (...) {
5157       {
5158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5159       };
5160     }
5161   }
5162
5163 }
5164
5165
5166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
5167   void * jresult ;
5168   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5169   float *result = 0 ;
5170
5171   arg1 = (Dali::Vector2 *)jarg1;
5172   {
5173     try {
5174       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
5175     } catch (std::out_of_range& e) {
5176       {
5177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5178       };
5179     } catch (std::exception& e) {
5180       {
5181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5182       };
5183     } catch (Dali::DaliException e) {
5184       {
5185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5186       };
5187     } catch (...) {
5188       {
5189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5190       };
5191     }
5192   }
5193
5194   jresult = (void *)result;
5195   return jresult;
5196 }
5197
5198
5199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
5200   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5201   float arg2 ;
5202
5203   arg1 = (Dali::Vector2 *)jarg1;
5204   arg2 = (float)jarg2;
5205   if (arg1) (arg1)->x = arg2;
5206 }
5207
5208
5209 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
5210   float jresult ;
5211   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5212   float result;
5213
5214   arg1 = (Dali::Vector2 *)jarg1;
5215   result = (float) ((arg1)->x);
5216   jresult = result;
5217   return jresult;
5218 }
5219
5220
5221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
5222   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5223   float arg2 ;
5224
5225   arg1 = (Dali::Vector2 *)jarg1;
5226   arg2 = (float)jarg2;
5227   if (arg1) (arg1)->width = arg2;
5228 }
5229
5230
5231 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
5232   float jresult ;
5233   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5234   float result;
5235
5236   arg1 = (Dali::Vector2 *)jarg1;
5237   result = (float) ((arg1)->width);
5238   jresult = result;
5239   return jresult;
5240 }
5241
5242
5243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
5244   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5245   float arg2 ;
5246
5247   arg1 = (Dali::Vector2 *)jarg1;
5248   arg2 = (float)jarg2;
5249   if (arg1) (arg1)->y = arg2;
5250 }
5251
5252
5253 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
5254   float jresult ;
5255   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5256   float result;
5257
5258   arg1 = (Dali::Vector2 *)jarg1;
5259   result = (float) ((arg1)->y);
5260   jresult = result;
5261   return jresult;
5262 }
5263
5264
5265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
5266   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5267   float arg2 ;
5268
5269   arg1 = (Dali::Vector2 *)jarg1;
5270   arg2 = (float)jarg2;
5271   if (arg1) (arg1)->height = arg2;
5272 }
5273
5274
5275 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
5276   float jresult ;
5277   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5278   float result;
5279
5280   arg1 = (Dali::Vector2 *)jarg1;
5281   result = (float) ((arg1)->height);
5282   jresult = result;
5283   return jresult;
5284 }
5285
5286
5287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
5288   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5289
5290   arg1 = (Dali::Vector2 *)jarg1;
5291   {
5292     try {
5293       delete arg1;
5294     } catch (std::out_of_range& e) {
5295       {
5296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5297       };
5298     } catch (std::exception& e) {
5299       {
5300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5301       };
5302     } catch (Dali::DaliException e) {
5303       {
5304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5305       };
5306     } catch (...) {
5307       {
5308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5309       };
5310     }
5311   }
5312
5313 }
5314
5315
5316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
5317   void * jresult ;
5318   Dali::Vector2 *arg1 = 0 ;
5319   Dali::Vector2 *arg2 = 0 ;
5320   Dali::Vector2 result;
5321
5322   arg1 = (Dali::Vector2 *)jarg1;
5323   if (!arg1) {
5324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5325     return 0;
5326   }
5327   arg2 = (Dali::Vector2 *)jarg2;
5328   if (!arg2) {
5329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5330     return 0;
5331   }
5332   {
5333     try {
5334       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5335     } catch (std::out_of_range& e) {
5336       {
5337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5338       };
5339     } catch (std::exception& e) {
5340       {
5341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5342       };
5343     } catch (Dali::DaliException e) {
5344       {
5345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5346       };
5347     } catch (...) {
5348       {
5349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5350       };
5351     }
5352   }
5353
5354   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5355   return jresult;
5356 }
5357
5358
5359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5360   void * jresult ;
5361   Dali::Vector2 *arg1 = 0 ;
5362   Dali::Vector2 *arg2 = 0 ;
5363   Dali::Vector2 result;
5364
5365   arg1 = (Dali::Vector2 *)jarg1;
5366   if (!arg1) {
5367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5368     return 0;
5369   }
5370   arg2 = (Dali::Vector2 *)jarg2;
5371   if (!arg2) {
5372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5373     return 0;
5374   }
5375   {
5376     try {
5377       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5378     } catch (std::out_of_range& e) {
5379       {
5380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5381       };
5382     } catch (std::exception& e) {
5383       {
5384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5385       };
5386     } catch (Dali::DaliException e) {
5387       {
5388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5389       };
5390     } catch (...) {
5391       {
5392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5393       };
5394     }
5395   }
5396
5397   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5398   return jresult;
5399 }
5400
5401
5402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5403   void * jresult ;
5404   Dali::Vector2 *arg1 = 0 ;
5405   float *arg2 = 0 ;
5406   float *arg3 = 0 ;
5407   float temp2 ;
5408   float temp3 ;
5409   Dali::Vector2 result;
5410
5411   arg1 = (Dali::Vector2 *)jarg1;
5412   if (!arg1) {
5413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5414     return 0;
5415   }
5416   temp2 = (float)jarg2;
5417   arg2 = &temp2;
5418   temp3 = (float)jarg3;
5419   arg3 = &temp3;
5420   {
5421     try {
5422       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5423     } catch (std::out_of_range& e) {
5424       {
5425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5426       };
5427     } catch (std::exception& e) {
5428       {
5429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5430       };
5431     } catch (Dali::DaliException e) {
5432       {
5433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5434       };
5435     } catch (...) {
5436       {
5437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5438       };
5439     }
5440   }
5441
5442   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5443   return jresult;
5444 }
5445
5446
5447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5448   void * jresult ;
5449   Dali::Vector3 *result = 0 ;
5450
5451   {
5452     try {
5453       result = (Dali::Vector3 *)new Dali::Vector3();
5454     } catch (std::out_of_range& e) {
5455       {
5456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5457       };
5458     } catch (std::exception& e) {
5459       {
5460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5461       };
5462     } catch (Dali::DaliException e) {
5463       {
5464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5465       };
5466     } catch (...) {
5467       {
5468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5469       };
5470     }
5471   }
5472
5473   jresult = (void *)result;
5474   return jresult;
5475 }
5476
5477
5478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5479   void * jresult ;
5480   float arg1 ;
5481   float arg2 ;
5482   float arg3 ;
5483   Dali::Vector3 *result = 0 ;
5484
5485   arg1 = (float)jarg1;
5486   arg2 = (float)jarg2;
5487   arg3 = (float)jarg3;
5488   {
5489     try {
5490       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5491     } catch (std::out_of_range& e) {
5492       {
5493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5494       };
5495     } catch (std::exception& e) {
5496       {
5497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5498       };
5499     } catch (Dali::DaliException e) {
5500       {
5501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5502       };
5503     } catch (...) {
5504       {
5505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5506       };
5507     }
5508   }
5509
5510   jresult = (void *)result;
5511   return jresult;
5512 }
5513
5514
5515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5516   void * jresult ;
5517   float *arg1 = (float *) 0 ;
5518   Dali::Vector3 *result = 0 ;
5519
5520   arg1 = jarg1;
5521   {
5522     try {
5523       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5524     } catch (std::out_of_range& e) {
5525       {
5526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5527       };
5528     } catch (std::exception& e) {
5529       {
5530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5531       };
5532     } catch (Dali::DaliException e) {
5533       {
5534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5535       };
5536     } catch (...) {
5537       {
5538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5539       };
5540     }
5541   }
5542
5543   jresult = (void *)result;
5544
5545
5546   return jresult;
5547 }
5548
5549
5550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5551   void * jresult ;
5552   Dali::Vector2 *arg1 = 0 ;
5553   Dali::Vector3 *result = 0 ;
5554
5555   arg1 = (Dali::Vector2 *)jarg1;
5556   if (!arg1) {
5557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5558     return 0;
5559   }
5560   {
5561     try {
5562       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5563     } catch (std::out_of_range& e) {
5564       {
5565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5566       };
5567     } catch (std::exception& e) {
5568       {
5569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5570       };
5571     } catch (Dali::DaliException e) {
5572       {
5573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5574       };
5575     } catch (...) {
5576       {
5577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5578       };
5579     }
5580   }
5581
5582   jresult = (void *)result;
5583   return jresult;
5584 }
5585
5586
5587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5588   void * jresult ;
5589   Dali::Vector4 *arg1 = 0 ;
5590   Dali::Vector3 *result = 0 ;
5591
5592   arg1 = (Dali::Vector4 *)jarg1;
5593   if (!arg1) {
5594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5595     return 0;
5596   }
5597   {
5598     try {
5599       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5600     } catch (std::out_of_range& e) {
5601       {
5602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5603       };
5604     } catch (std::exception& e) {
5605       {
5606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5607       };
5608     } catch (Dali::DaliException e) {
5609       {
5610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5611       };
5612     } catch (...) {
5613       {
5614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5615       };
5616     }
5617   }
5618
5619   jresult = (void *)result;
5620   return jresult;
5621 }
5622
5623
5624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5625   void * jresult ;
5626   Dali::Vector3 *result = 0 ;
5627
5628   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5629   jresult = (void *)result;
5630   return jresult;
5631 }
5632
5633
5634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5635   void * jresult ;
5636   Dali::Vector3 *result = 0 ;
5637
5638   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5639   jresult = (void *)result;
5640   return jresult;
5641 }
5642
5643
5644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5645   void * jresult ;
5646   Dali::Vector3 *result = 0 ;
5647
5648   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5649   jresult = (void *)result;
5650   return jresult;
5651 }
5652
5653
5654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5655   void * jresult ;
5656   Dali::Vector3 *result = 0 ;
5657
5658   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5659   jresult = (void *)result;
5660   return jresult;
5661 }
5662
5663
5664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5665   void * jresult ;
5666   Dali::Vector3 *result = 0 ;
5667
5668   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5669   jresult = (void *)result;
5670   return jresult;
5671 }
5672
5673
5674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5675   void * jresult ;
5676   Dali::Vector3 *result = 0 ;
5677
5678   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5679   jresult = (void *)result;
5680   return jresult;
5681 }
5682
5683
5684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5685   void * jresult ;
5686   Dali::Vector3 *result = 0 ;
5687
5688   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5689   jresult = (void *)result;
5690   return jresult;
5691 }
5692
5693
5694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5695   void * jresult ;
5696   Dali::Vector3 *result = 0 ;
5697
5698   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5699   jresult = (void *)result;
5700   return jresult;
5701 }
5702
5703
5704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5705   void * jresult ;
5706   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5707   float *arg2 = (float *) 0 ;
5708   Dali::Vector3 *result = 0 ;
5709
5710   arg1 = (Dali::Vector3 *)jarg1;
5711   arg2 = jarg2;
5712   {
5713     try {
5714       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5715     } catch (std::out_of_range& e) {
5716       {
5717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5718       };
5719     } catch (std::exception& e) {
5720       {
5721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5722       };
5723     } catch (Dali::DaliException e) {
5724       {
5725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5726       };
5727     } catch (...) {
5728       {
5729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5730       };
5731     }
5732   }
5733
5734   jresult = (void *)result;
5735
5736
5737   return jresult;
5738 }
5739
5740
5741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5742   void * jresult ;
5743   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5744   Dali::Vector2 *arg2 = 0 ;
5745   Dali::Vector3 *result = 0 ;
5746
5747   arg1 = (Dali::Vector3 *)jarg1;
5748   arg2 = (Dali::Vector2 *)jarg2;
5749   if (!arg2) {
5750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5751     return 0;
5752   }
5753   {
5754     try {
5755       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5756     } catch (std::out_of_range& e) {
5757       {
5758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5759       };
5760     } catch (std::exception& e) {
5761       {
5762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5763       };
5764     } catch (Dali::DaliException e) {
5765       {
5766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5767       };
5768     } catch (...) {
5769       {
5770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5771       };
5772     }
5773   }
5774
5775   jresult = (void *)result;
5776   return jresult;
5777 }
5778
5779
5780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5781   void * jresult ;
5782   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5783   Dali::Vector4 *arg2 = 0 ;
5784   Dali::Vector3 *result = 0 ;
5785
5786   arg1 = (Dali::Vector3 *)jarg1;
5787   arg2 = (Dali::Vector4 *)jarg2;
5788   if (!arg2) {
5789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5790     return 0;
5791   }
5792   {
5793     try {
5794       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5795     } catch (std::out_of_range& e) {
5796       {
5797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5798       };
5799     } catch (std::exception& e) {
5800       {
5801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5802       };
5803     } catch (Dali::DaliException e) {
5804       {
5805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5806       };
5807     } catch (...) {
5808       {
5809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5810       };
5811     }
5812   }
5813
5814   jresult = (void *)result;
5815   return jresult;
5816 }
5817
5818
5819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5820   void * jresult ;
5821   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5822   Dali::Vector3 *arg2 = 0 ;
5823   Dali::Vector3 result;
5824
5825   arg1 = (Dali::Vector3 *)jarg1;
5826   arg2 = (Dali::Vector3 *)jarg2;
5827   if (!arg2) {
5828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5829     return 0;
5830   }
5831   {
5832     try {
5833       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5834     } catch (std::out_of_range& e) {
5835       {
5836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5837       };
5838     } catch (std::exception& e) {
5839       {
5840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5841       };
5842     } catch (Dali::DaliException e) {
5843       {
5844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5845       };
5846     } catch (...) {
5847       {
5848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5849       };
5850     }
5851   }
5852
5853   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5854   return jresult;
5855 }
5856
5857
5858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5859   void * jresult ;
5860   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5861   Dali::Vector3 *arg2 = 0 ;
5862   Dali::Vector3 *result = 0 ;
5863
5864   arg1 = (Dali::Vector3 *)jarg1;
5865   arg2 = (Dali::Vector3 *)jarg2;
5866   if (!arg2) {
5867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5868     return 0;
5869   }
5870   {
5871     try {
5872       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
5873     } catch (std::out_of_range& e) {
5874       {
5875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5876       };
5877     } catch (std::exception& e) {
5878       {
5879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5880       };
5881     } catch (Dali::DaliException e) {
5882       {
5883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5884       };
5885     } catch (...) {
5886       {
5887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5888       };
5889     }
5890   }
5891
5892   jresult = (void *)result;
5893   return jresult;
5894 }
5895
5896
5897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
5898   void * jresult ;
5899   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5900   Dali::Vector3 *arg2 = 0 ;
5901   Dali::Vector3 result;
5902
5903   arg1 = (Dali::Vector3 *)jarg1;
5904   arg2 = (Dali::Vector3 *)jarg2;
5905   if (!arg2) {
5906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5907     return 0;
5908   }
5909   {
5910     try {
5911       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
5912     } catch (std::out_of_range& e) {
5913       {
5914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5915       };
5916     } catch (std::exception& e) {
5917       {
5918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5919       };
5920     } catch (Dali::DaliException e) {
5921       {
5922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5923       };
5924     } catch (...) {
5925       {
5926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5927       };
5928     }
5929   }
5930
5931   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5932   return jresult;
5933 }
5934
5935
5936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
5937   void * jresult ;
5938   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5939   Dali::Vector3 *arg2 = 0 ;
5940   Dali::Vector3 *result = 0 ;
5941
5942   arg1 = (Dali::Vector3 *)jarg1;
5943   arg2 = (Dali::Vector3 *)jarg2;
5944   if (!arg2) {
5945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5946     return 0;
5947   }
5948   {
5949     try {
5950       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
5951     } catch (std::out_of_range& e) {
5952       {
5953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5954       };
5955     } catch (std::exception& e) {
5956       {
5957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5958       };
5959     } catch (Dali::DaliException e) {
5960       {
5961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5962       };
5963     } catch (...) {
5964       {
5965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5966       };
5967     }
5968   }
5969
5970   jresult = (void *)result;
5971   return jresult;
5972 }
5973
5974
5975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
5976   void * jresult ;
5977   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5978   Dali::Vector3 *arg2 = 0 ;
5979   Dali::Vector3 result;
5980
5981   arg1 = (Dali::Vector3 *)jarg1;
5982   arg2 = (Dali::Vector3 *)jarg2;
5983   if (!arg2) {
5984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5985     return 0;
5986   }
5987   {
5988     try {
5989       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
5990     } catch (std::out_of_range& e) {
5991       {
5992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5993       };
5994     } catch (std::exception& e) {
5995       {
5996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5997       };
5998     } catch (Dali::DaliException e) {
5999       {
6000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6001       };
6002     } catch (...) {
6003       {
6004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6005       };
6006     }
6007   }
6008
6009   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6010   return jresult;
6011 }
6012
6013
6014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
6015   void * jresult ;
6016   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6017   float arg2 ;
6018   Dali::Vector3 result;
6019
6020   arg1 = (Dali::Vector3 *)jarg1;
6021   arg2 = (float)jarg2;
6022   {
6023     try {
6024       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
6025     } catch (std::out_of_range& e) {
6026       {
6027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6028       };
6029     } catch (std::exception& e) {
6030       {
6031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6032       };
6033     } catch (Dali::DaliException e) {
6034       {
6035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6036       };
6037     } catch (...) {
6038       {
6039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6040       };
6041     }
6042   }
6043
6044   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6045   return jresult;
6046 }
6047
6048
6049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6050   void * jresult ;
6051   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6052   Dali::Vector3 *arg2 = 0 ;
6053   Dali::Vector3 *result = 0 ;
6054
6055   arg1 = (Dali::Vector3 *)jarg1;
6056   arg2 = (Dali::Vector3 *)jarg2;
6057   if (!arg2) {
6058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6059     return 0;
6060   }
6061   {
6062     try {
6063       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
6064     } catch (std::out_of_range& e) {
6065       {
6066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6067       };
6068     } catch (std::exception& e) {
6069       {
6070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6071       };
6072     } catch (Dali::DaliException e) {
6073       {
6074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6075       };
6076     } catch (...) {
6077       {
6078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6079       };
6080     }
6081   }
6082
6083   jresult = (void *)result;
6084   return jresult;
6085 }
6086
6087
6088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
6089   void * jresult ;
6090   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6091   float arg2 ;
6092   Dali::Vector3 *result = 0 ;
6093
6094   arg1 = (Dali::Vector3 *)jarg1;
6095   arg2 = (float)jarg2;
6096   {
6097     try {
6098       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
6099     } catch (std::out_of_range& e) {
6100       {
6101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6102       };
6103     } catch (std::exception& e) {
6104       {
6105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6106       };
6107     } catch (Dali::DaliException e) {
6108       {
6109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6110       };
6111     } catch (...) {
6112       {
6113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6114       };
6115     }
6116   }
6117
6118   jresult = (void *)result;
6119   return jresult;
6120 }
6121
6122
6123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
6124   void * jresult ;
6125   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6126   Dali::Quaternion *arg2 = 0 ;
6127   Dali::Vector3 *result = 0 ;
6128
6129   arg1 = (Dali::Vector3 *)jarg1;
6130   arg2 = (Dali::Quaternion *)jarg2;
6131   if (!arg2) {
6132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
6133     return 0;
6134   }
6135   {
6136     try {
6137       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
6138     } catch (std::out_of_range& e) {
6139       {
6140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6141       };
6142     } catch (std::exception& e) {
6143       {
6144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6145       };
6146     } catch (Dali::DaliException e) {
6147       {
6148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6149       };
6150     } catch (...) {
6151       {
6152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6153       };
6154     }
6155   }
6156
6157   jresult = (void *)result;
6158   return jresult;
6159 }
6160
6161
6162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
6163   void * jresult ;
6164   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6165   Dali::Vector3 *arg2 = 0 ;
6166   Dali::Vector3 result;
6167
6168   arg1 = (Dali::Vector3 *)jarg1;
6169   arg2 = (Dali::Vector3 *)jarg2;
6170   if (!arg2) {
6171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6172     return 0;
6173   }
6174   {
6175     try {
6176       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
6177     } catch (std::out_of_range& e) {
6178       {
6179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6180       };
6181     } catch (std::exception& e) {
6182       {
6183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6184       };
6185     } catch (Dali::DaliException e) {
6186       {
6187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6188       };
6189     } catch (...) {
6190       {
6191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6192       };
6193     }
6194   }
6195
6196   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6197   return jresult;
6198 }
6199
6200
6201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
6202   void * jresult ;
6203   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6204   float arg2 ;
6205   Dali::Vector3 result;
6206
6207   arg1 = (Dali::Vector3 *)jarg1;
6208   arg2 = (float)jarg2;
6209   {
6210     try {
6211       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
6212     } catch (std::out_of_range& e) {
6213       {
6214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6215       };
6216     } catch (std::exception& e) {
6217       {
6218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6219       };
6220     } catch (Dali::DaliException e) {
6221       {
6222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6223       };
6224     } catch (...) {
6225       {
6226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6227       };
6228     }
6229   }
6230
6231   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6232   return jresult;
6233 }
6234
6235
6236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
6237   void * jresult ;
6238   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6239   Dali::Vector3 *arg2 = 0 ;
6240   Dali::Vector3 *result = 0 ;
6241
6242   arg1 = (Dali::Vector3 *)jarg1;
6243   arg2 = (Dali::Vector3 *)jarg2;
6244   if (!arg2) {
6245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6246     return 0;
6247   }
6248   {
6249     try {
6250       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
6251     } catch (std::out_of_range& e) {
6252       {
6253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6254       };
6255     } catch (std::exception& e) {
6256       {
6257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6258       };
6259     } catch (Dali::DaliException e) {
6260       {
6261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6262       };
6263     } catch (...) {
6264       {
6265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6266       };
6267     }
6268   }
6269
6270   jresult = (void *)result;
6271   return jresult;
6272 }
6273
6274
6275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
6276   void * jresult ;
6277   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6278   float arg2 ;
6279   Dali::Vector3 *result = 0 ;
6280
6281   arg1 = (Dali::Vector3 *)jarg1;
6282   arg2 = (float)jarg2;
6283   {
6284     try {
6285       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
6286     } catch (std::out_of_range& e) {
6287       {
6288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6289       };
6290     } catch (std::exception& e) {
6291       {
6292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6293       };
6294     } catch (Dali::DaliException e) {
6295       {
6296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6297       };
6298     } catch (...) {
6299       {
6300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6301       };
6302     }
6303   }
6304
6305   jresult = (void *)result;
6306   return jresult;
6307 }
6308
6309
6310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
6311   void * jresult ;
6312   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6313   Dali::Vector3 result;
6314
6315   arg1 = (Dali::Vector3 *)jarg1;
6316   {
6317     try {
6318       result = ((Dali::Vector3 const *)arg1)->operator -();
6319     } catch (std::out_of_range& e) {
6320       {
6321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6322       };
6323     } catch (std::exception& e) {
6324       {
6325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6326       };
6327     } catch (Dali::DaliException e) {
6328       {
6329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6330       };
6331     } catch (...) {
6332       {
6333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6334       };
6335     }
6336   }
6337
6338   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6339   return jresult;
6340 }
6341
6342
6343 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
6344   unsigned int jresult ;
6345   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6346   Dali::Vector3 *arg2 = 0 ;
6347   bool result;
6348
6349   arg1 = (Dali::Vector3 *)jarg1;
6350   arg2 = (Dali::Vector3 *)jarg2;
6351   if (!arg2) {
6352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6353     return 0;
6354   }
6355   {
6356     try {
6357       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
6358     } catch (std::out_of_range& e) {
6359       {
6360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6361       };
6362     } catch (std::exception& e) {
6363       {
6364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6365       };
6366     } catch (Dali::DaliException e) {
6367       {
6368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6369       };
6370     } catch (...) {
6371       {
6372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6373       };
6374     }
6375   }
6376
6377   jresult = result;
6378   return jresult;
6379 }
6380
6381
6382 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
6383   unsigned int jresult ;
6384   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6385   Dali::Vector3 *arg2 = 0 ;
6386   bool result;
6387
6388   arg1 = (Dali::Vector3 *)jarg1;
6389   arg2 = (Dali::Vector3 *)jarg2;
6390   if (!arg2) {
6391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6392     return 0;
6393   }
6394   {
6395     try {
6396       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
6397     } catch (std::out_of_range& e) {
6398       {
6399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6400       };
6401     } catch (std::exception& e) {
6402       {
6403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6404       };
6405     } catch (Dali::DaliException e) {
6406       {
6407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6408       };
6409     } catch (...) {
6410       {
6411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6412       };
6413     }
6414   }
6415
6416   jresult = result;
6417   return jresult;
6418 }
6419
6420
6421 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
6422   float jresult ;
6423   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6424   unsigned int arg2 ;
6425   float *result = 0 ;
6426
6427   arg1 = (Dali::Vector3 *)jarg1;
6428   arg2 = (unsigned int)jarg2;
6429   {
6430     try {
6431       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
6432     } catch (std::out_of_range& e) {
6433       {
6434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6435       };
6436     } catch (std::exception& e) {
6437       {
6438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6439       };
6440     } catch (Dali::DaliException e) {
6441       {
6442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6443       };
6444     } catch (...) {
6445       {
6446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6447       };
6448     }
6449   }
6450
6451   jresult = *result;
6452   return jresult;
6453 }
6454
6455
6456 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
6457   float jresult ;
6458   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6459   Dali::Vector3 *arg2 = 0 ;
6460   float result;
6461
6462   arg1 = (Dali::Vector3 *)jarg1;
6463   arg2 = (Dali::Vector3 *)jarg2;
6464   if (!arg2) {
6465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6466     return 0;
6467   }
6468   {
6469     try {
6470       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
6471     } catch (std::out_of_range& e) {
6472       {
6473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6474       };
6475     } catch (std::exception& e) {
6476       {
6477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6478       };
6479     } catch (Dali::DaliException e) {
6480       {
6481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6482       };
6483     } catch (...) {
6484       {
6485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6486       };
6487     }
6488   }
6489
6490   jresult = result;
6491   return jresult;
6492 }
6493
6494
6495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6496   void * jresult ;
6497   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6498   Dali::Vector3 *arg2 = 0 ;
6499   Dali::Vector3 result;
6500
6501   arg1 = (Dali::Vector3 *)jarg1;
6502   arg2 = (Dali::Vector3 *)jarg2;
6503   if (!arg2) {
6504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6505     return 0;
6506   }
6507   {
6508     try {
6509       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6510     } catch (std::out_of_range& e) {
6511       {
6512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6513       };
6514     } catch (std::exception& e) {
6515       {
6516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6517       };
6518     } catch (Dali::DaliException e) {
6519       {
6520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6521       };
6522     } catch (...) {
6523       {
6524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6525       };
6526     }
6527   }
6528
6529   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6530   return jresult;
6531 }
6532
6533
6534 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6535   float jresult ;
6536   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6537   float result;
6538
6539   arg1 = (Dali::Vector3 *)jarg1;
6540   {
6541     try {
6542       result = (float)((Dali::Vector3 const *)arg1)->Length();
6543     } catch (std::out_of_range& e) {
6544       {
6545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6546       };
6547     } catch (std::exception& e) {
6548       {
6549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6550       };
6551     } catch (Dali::DaliException e) {
6552       {
6553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6554       };
6555     } catch (...) {
6556       {
6557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6558       };
6559     }
6560   }
6561
6562   jresult = result;
6563   return jresult;
6564 }
6565
6566
6567 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6568   float jresult ;
6569   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6570   float result;
6571
6572   arg1 = (Dali::Vector3 *)jarg1;
6573   {
6574     try {
6575       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6576     } catch (std::out_of_range& e) {
6577       {
6578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6579       };
6580     } catch (std::exception& e) {
6581       {
6582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6583       };
6584     } catch (Dali::DaliException e) {
6585       {
6586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6587       };
6588     } catch (...) {
6589       {
6590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6591       };
6592     }
6593   }
6594
6595   jresult = result;
6596   return jresult;
6597 }
6598
6599
6600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6601   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6602
6603   arg1 = (Dali::Vector3 *)jarg1;
6604   {
6605     try {
6606       (arg1)->Normalize();
6607     } catch (std::out_of_range& e) {
6608       {
6609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6610       };
6611     } catch (std::exception& e) {
6612       {
6613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6614       };
6615     } catch (Dali::DaliException e) {
6616       {
6617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6618       };
6619     } catch (...) {
6620       {
6621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6622       };
6623     }
6624   }
6625
6626 }
6627
6628
6629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6630   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6631   Dali::Vector3 *arg2 = 0 ;
6632   Dali::Vector3 *arg3 = 0 ;
6633
6634   arg1 = (Dali::Vector3 *)jarg1;
6635   arg2 = (Dali::Vector3 *)jarg2;
6636   if (!arg2) {
6637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6638     return ;
6639   }
6640   arg3 = (Dali::Vector3 *)jarg3;
6641   if (!arg3) {
6642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6643     return ;
6644   }
6645   {
6646     try {
6647       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6648     } catch (std::out_of_range& e) {
6649       {
6650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6651       };
6652     } catch (std::exception& e) {
6653       {
6654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6655       };
6656     } catch (Dali::DaliException e) {
6657       {
6658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6659       };
6660     } catch (...) {
6661       {
6662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6663       };
6664     }
6665   }
6666
6667 }
6668
6669
6670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6671   void * jresult ;
6672   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6673   float *result = 0 ;
6674
6675   arg1 = (Dali::Vector3 *)jarg1;
6676   {
6677     try {
6678       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6679     } catch (std::out_of_range& e) {
6680       {
6681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6682       };
6683     } catch (std::exception& e) {
6684       {
6685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6686       };
6687     } catch (Dali::DaliException e) {
6688       {
6689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6690       };
6691     } catch (...) {
6692       {
6693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6694       };
6695     }
6696   }
6697
6698   jresult = (void *)result;
6699   return jresult;
6700 }
6701
6702
6703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6704   void * jresult ;
6705   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6706   Dali::Vector2 *result = 0 ;
6707
6708   arg1 = (Dali::Vector3 *)jarg1;
6709   {
6710     try {
6711       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6712     } catch (std::out_of_range& e) {
6713       {
6714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6715       };
6716     } catch (std::exception& e) {
6717       {
6718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6719       };
6720     } catch (Dali::DaliException e) {
6721       {
6722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6723       };
6724     } catch (...) {
6725       {
6726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6727       };
6728     }
6729   }
6730
6731   jresult = (void *)result;
6732   return jresult;
6733 }
6734
6735
6736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6737   void * jresult ;
6738   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6739   Dali::Vector2 *result = 0 ;
6740
6741   arg1 = (Dali::Vector3 *)jarg1;
6742   {
6743     try {
6744       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6745     } catch (std::out_of_range& e) {
6746       {
6747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6748       };
6749     } catch (std::exception& e) {
6750       {
6751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6752       };
6753     } catch (Dali::DaliException e) {
6754       {
6755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6756       };
6757     } catch (...) {
6758       {
6759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6760       };
6761     }
6762   }
6763
6764   jresult = (void *)result;
6765   return jresult;
6766 }
6767
6768
6769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6770   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6771   float arg2 ;
6772
6773   arg1 = (Dali::Vector3 *)jarg1;
6774   arg2 = (float)jarg2;
6775   if (arg1) (arg1)->x = arg2;
6776 }
6777
6778
6779 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6780   float jresult ;
6781   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6782   float result;
6783
6784   arg1 = (Dali::Vector3 *)jarg1;
6785   result = (float) ((arg1)->x);
6786   jresult = result;
6787   return jresult;
6788 }
6789
6790
6791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6792   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6793   float arg2 ;
6794
6795   arg1 = (Dali::Vector3 *)jarg1;
6796   arg2 = (float)jarg2;
6797   if (arg1) (arg1)->width = arg2;
6798 }
6799
6800
6801 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6802   float jresult ;
6803   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6804   float result;
6805
6806   arg1 = (Dali::Vector3 *)jarg1;
6807   result = (float) ((arg1)->width);
6808   jresult = result;
6809   return jresult;
6810 }
6811
6812
6813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6814   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6815   float arg2 ;
6816
6817   arg1 = (Dali::Vector3 *)jarg1;
6818   arg2 = (float)jarg2;
6819   if (arg1) (arg1)->r = arg2;
6820 }
6821
6822
6823 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6824   float jresult ;
6825   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6826   float result;
6827
6828   arg1 = (Dali::Vector3 *)jarg1;
6829   result = (float) ((arg1)->r);
6830   jresult = result;
6831   return jresult;
6832 }
6833
6834
6835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6836   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6837   float arg2 ;
6838
6839   arg1 = (Dali::Vector3 *)jarg1;
6840   arg2 = (float)jarg2;
6841   if (arg1) (arg1)->y = arg2;
6842 }
6843
6844
6845 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6846   float jresult ;
6847   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6848   float result;
6849
6850   arg1 = (Dali::Vector3 *)jarg1;
6851   result = (float) ((arg1)->y);
6852   jresult = result;
6853   return jresult;
6854 }
6855
6856
6857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6858   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6859   float arg2 ;
6860
6861   arg1 = (Dali::Vector3 *)jarg1;
6862   arg2 = (float)jarg2;
6863   if (arg1) (arg1)->height = arg2;
6864 }
6865
6866
6867 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
6868   float jresult ;
6869   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6870   float result;
6871
6872   arg1 = (Dali::Vector3 *)jarg1;
6873   result = (float) ((arg1)->height);
6874   jresult = result;
6875   return jresult;
6876 }
6877
6878
6879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
6880   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6881   float arg2 ;
6882
6883   arg1 = (Dali::Vector3 *)jarg1;
6884   arg2 = (float)jarg2;
6885   if (arg1) (arg1)->g = arg2;
6886 }
6887
6888
6889 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
6890   float jresult ;
6891   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6892   float result;
6893
6894   arg1 = (Dali::Vector3 *)jarg1;
6895   result = (float) ((arg1)->g);
6896   jresult = result;
6897   return jresult;
6898 }
6899
6900
6901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
6902   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6903   float arg2 ;
6904
6905   arg1 = (Dali::Vector3 *)jarg1;
6906   arg2 = (float)jarg2;
6907   if (arg1) (arg1)->z = arg2;
6908 }
6909
6910
6911 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
6912   float jresult ;
6913   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6914   float result;
6915
6916   arg1 = (Dali::Vector3 *)jarg1;
6917   result = (float) ((arg1)->z);
6918   jresult = result;
6919   return jresult;
6920 }
6921
6922
6923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
6924   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6925   float arg2 ;
6926
6927   arg1 = (Dali::Vector3 *)jarg1;
6928   arg2 = (float)jarg2;
6929   if (arg1) (arg1)->depth = arg2;
6930 }
6931
6932
6933 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
6934   float jresult ;
6935   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6936   float result;
6937
6938   arg1 = (Dali::Vector3 *)jarg1;
6939   result = (float) ((arg1)->depth);
6940   jresult = result;
6941   return jresult;
6942 }
6943
6944
6945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
6946   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6947   float arg2 ;
6948
6949   arg1 = (Dali::Vector3 *)jarg1;
6950   arg2 = (float)jarg2;
6951   if (arg1) (arg1)->b = arg2;
6952 }
6953
6954
6955 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
6956   float jresult ;
6957   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6958   float result;
6959
6960   arg1 = (Dali::Vector3 *)jarg1;
6961   result = (float) ((arg1)->b);
6962   jresult = result;
6963   return jresult;
6964 }
6965
6966
6967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
6968   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6969
6970   arg1 = (Dali::Vector3 *)jarg1;
6971   {
6972     try {
6973       delete arg1;
6974     } catch (std::out_of_range& e) {
6975       {
6976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6977       };
6978     } catch (std::exception& e) {
6979       {
6980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6981       };
6982     } catch (Dali::DaliException e) {
6983       {
6984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6985       };
6986     } catch (...) {
6987       {
6988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6989       };
6990     }
6991   }
6992
6993 }
6994
6995
6996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
6997   void * jresult ;
6998   Dali::Vector3 *arg1 = 0 ;
6999   Dali::Vector3 *arg2 = 0 ;
7000   Dali::Vector3 result;
7001
7002   arg1 = (Dali::Vector3 *)jarg1;
7003   if (!arg1) {
7004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7005     return 0;
7006   }
7007   arg2 = (Dali::Vector3 *)jarg2;
7008   if (!arg2) {
7009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7010     return 0;
7011   }
7012   {
7013     try {
7014       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7015     } catch (std::out_of_range& e) {
7016       {
7017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7018       };
7019     } catch (std::exception& e) {
7020       {
7021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7022       };
7023     } catch (Dali::DaliException e) {
7024       {
7025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7026       };
7027     } catch (...) {
7028       {
7029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7030       };
7031     }
7032   }
7033
7034   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7035   return jresult;
7036 }
7037
7038
7039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
7040   void * jresult ;
7041   Dali::Vector3 *arg1 = 0 ;
7042   Dali::Vector3 *arg2 = 0 ;
7043   Dali::Vector3 result;
7044
7045   arg1 = (Dali::Vector3 *)jarg1;
7046   if (!arg1) {
7047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7048     return 0;
7049   }
7050   arg2 = (Dali::Vector3 *)jarg2;
7051   if (!arg2) {
7052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7053     return 0;
7054   }
7055   {
7056     try {
7057       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7058     } catch (std::out_of_range& e) {
7059       {
7060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7061       };
7062     } catch (std::exception& e) {
7063       {
7064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7065       };
7066     } catch (Dali::DaliException e) {
7067       {
7068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7069       };
7070     } catch (...) {
7071       {
7072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7073       };
7074     }
7075   }
7076
7077   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7078   return jresult;
7079 }
7080
7081
7082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
7083   void * jresult ;
7084   Dali::Vector3 *arg1 = 0 ;
7085   float *arg2 = 0 ;
7086   float *arg3 = 0 ;
7087   float temp2 ;
7088   float temp3 ;
7089   Dali::Vector3 result;
7090
7091   arg1 = (Dali::Vector3 *)jarg1;
7092   if (!arg1) {
7093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7094     return 0;
7095   }
7096   temp2 = (float)jarg2;
7097   arg2 = &temp2;
7098   temp3 = (float)jarg3;
7099   arg3 = &temp3;
7100   {
7101     try {
7102       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7103     } catch (std::out_of_range& e) {
7104       {
7105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7106       };
7107     } catch (std::exception& e) {
7108       {
7109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7110       };
7111     } catch (Dali::DaliException e) {
7112       {
7113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7114       };
7115     } catch (...) {
7116       {
7117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7118       };
7119     }
7120   }
7121
7122   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7123   return jresult;
7124 }
7125
7126
7127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
7128   void * jresult ;
7129   Dali::Vector4 *result = 0 ;
7130
7131   {
7132     try {
7133       result = (Dali::Vector4 *)new Dali::Vector4();
7134     } catch (std::out_of_range& e) {
7135       {
7136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7137       };
7138     } catch (std::exception& e) {
7139       {
7140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7141       };
7142     } catch (Dali::DaliException e) {
7143       {
7144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7145       };
7146     } catch (...) {
7147       {
7148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7149       };
7150     }
7151   }
7152
7153   jresult = (void *)result;
7154   return jresult;
7155 }
7156
7157
7158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
7159   void * jresult ;
7160   float arg1 ;
7161   float arg2 ;
7162   float arg3 ;
7163   float arg4 ;
7164   Dali::Vector4 *result = 0 ;
7165
7166   arg1 = (float)jarg1;
7167   arg2 = (float)jarg2;
7168   arg3 = (float)jarg3;
7169   arg4 = (float)jarg4;
7170   {
7171     try {
7172       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
7173     } catch (std::out_of_range& e) {
7174       {
7175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7176       };
7177     } catch (std::exception& e) {
7178       {
7179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7180       };
7181     } catch (Dali::DaliException e) {
7182       {
7183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7184       };
7185     } catch (...) {
7186       {
7187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7188       };
7189     }
7190   }
7191
7192   jresult = (void *)result;
7193   return jresult;
7194 }
7195
7196
7197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
7198   void * jresult ;
7199   float *arg1 = (float *) 0 ;
7200   Dali::Vector4 *result = 0 ;
7201
7202   arg1 = jarg1;
7203   {
7204     try {
7205       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
7206     } catch (std::out_of_range& e) {
7207       {
7208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7209       };
7210     } catch (std::exception& e) {
7211       {
7212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7213       };
7214     } catch (Dali::DaliException e) {
7215       {
7216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7217       };
7218     } catch (...) {
7219       {
7220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7221       };
7222     }
7223   }
7224
7225   jresult = (void *)result;
7226
7227
7228   return jresult;
7229 }
7230
7231
7232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
7233   void * jresult ;
7234   Dali::Vector2 *arg1 = 0 ;
7235   Dali::Vector4 *result = 0 ;
7236
7237   arg1 = (Dali::Vector2 *)jarg1;
7238   if (!arg1) {
7239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7240     return 0;
7241   }
7242   {
7243     try {
7244       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
7245     } catch (std::out_of_range& e) {
7246       {
7247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7248       };
7249     } catch (std::exception& e) {
7250       {
7251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7252       };
7253     } catch (Dali::DaliException e) {
7254       {
7255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7256       };
7257     } catch (...) {
7258       {
7259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7260       };
7261     }
7262   }
7263
7264   jresult = (void *)result;
7265   return jresult;
7266 }
7267
7268
7269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
7270   void * jresult ;
7271   Dali::Vector3 *arg1 = 0 ;
7272   Dali::Vector4 *result = 0 ;
7273
7274   arg1 = (Dali::Vector3 *)jarg1;
7275   if (!arg1) {
7276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7277     return 0;
7278   }
7279   {
7280     try {
7281       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
7282     } catch (std::out_of_range& e) {
7283       {
7284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7285       };
7286     } catch (std::exception& e) {
7287       {
7288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7289       };
7290     } catch (Dali::DaliException e) {
7291       {
7292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7293       };
7294     } catch (...) {
7295       {
7296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7297       };
7298     }
7299   }
7300
7301   jresult = (void *)result;
7302   return jresult;
7303 }
7304
7305
7306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
7307   void * jresult ;
7308   Dali::Vector4 *result = 0 ;
7309
7310   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
7311   jresult = (void *)result;
7312   return jresult;
7313 }
7314
7315
7316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
7317   void * jresult ;
7318   Dali::Vector4 *result = 0 ;
7319
7320   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
7321   jresult = (void *)result;
7322   return jresult;
7323 }
7324
7325
7326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
7327   void * jresult ;
7328   Dali::Vector4 *result = 0 ;
7329
7330   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
7331   jresult = (void *)result;
7332   return jresult;
7333 }
7334
7335
7336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
7337   void * jresult ;
7338   Dali::Vector4 *result = 0 ;
7339
7340   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
7341   jresult = (void *)result;
7342   return jresult;
7343 }
7344
7345
7346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
7347   void * jresult ;
7348   Dali::Vector4 *result = 0 ;
7349
7350   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
7351   jresult = (void *)result;
7352   return jresult;
7353 }
7354
7355
7356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
7357   void * jresult ;
7358   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7359   float *arg2 = (float *) 0 ;
7360   Dali::Vector4 *result = 0 ;
7361
7362   arg1 = (Dali::Vector4 *)jarg1;
7363   arg2 = jarg2;
7364   {
7365     try {
7366       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
7367     } catch (std::out_of_range& e) {
7368       {
7369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7370       };
7371     } catch (std::exception& e) {
7372       {
7373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7374       };
7375     } catch (Dali::DaliException e) {
7376       {
7377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7378       };
7379     } catch (...) {
7380       {
7381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7382       };
7383     }
7384   }
7385
7386   jresult = (void *)result;
7387
7388
7389   return jresult;
7390 }
7391
7392
7393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
7394   void * jresult ;
7395   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7396   Dali::Vector2 *arg2 = 0 ;
7397   Dali::Vector4 *result = 0 ;
7398
7399   arg1 = (Dali::Vector4 *)jarg1;
7400   arg2 = (Dali::Vector2 *)jarg2;
7401   if (!arg2) {
7402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7403     return 0;
7404   }
7405   {
7406     try {
7407       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
7408     } catch (std::out_of_range& e) {
7409       {
7410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7411       };
7412     } catch (std::exception& e) {
7413       {
7414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7415       };
7416     } catch (Dali::DaliException e) {
7417       {
7418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7419       };
7420     } catch (...) {
7421       {
7422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7423       };
7424     }
7425   }
7426
7427   jresult = (void *)result;
7428   return jresult;
7429 }
7430
7431
7432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
7433   void * jresult ;
7434   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7435   Dali::Vector3 *arg2 = 0 ;
7436   Dali::Vector4 *result = 0 ;
7437
7438   arg1 = (Dali::Vector4 *)jarg1;
7439   arg2 = (Dali::Vector3 *)jarg2;
7440   if (!arg2) {
7441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7442     return 0;
7443   }
7444   {
7445     try {
7446       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
7447     } catch (std::out_of_range& e) {
7448       {
7449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7450       };
7451     } catch (std::exception& e) {
7452       {
7453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7454       };
7455     } catch (Dali::DaliException e) {
7456       {
7457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7458       };
7459     } catch (...) {
7460       {
7461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7462       };
7463     }
7464   }
7465
7466   jresult = (void *)result;
7467   return jresult;
7468 }
7469
7470
7471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
7472   void * jresult ;
7473   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7474   Dali::Vector4 *arg2 = 0 ;
7475   Dali::Vector4 result;
7476
7477   arg1 = (Dali::Vector4 *)jarg1;
7478   arg2 = (Dali::Vector4 *)jarg2;
7479   if (!arg2) {
7480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7481     return 0;
7482   }
7483   {
7484     try {
7485       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
7486     } catch (std::out_of_range& e) {
7487       {
7488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7489       };
7490     } catch (std::exception& e) {
7491       {
7492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7493       };
7494     } catch (Dali::DaliException e) {
7495       {
7496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7497       };
7498     } catch (...) {
7499       {
7500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7501       };
7502     }
7503   }
7504
7505   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7506   return jresult;
7507 }
7508
7509
7510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
7511   void * jresult ;
7512   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7513   Dali::Vector4 *arg2 = 0 ;
7514   Dali::Vector4 *result = 0 ;
7515
7516   arg1 = (Dali::Vector4 *)jarg1;
7517   arg2 = (Dali::Vector4 *)jarg2;
7518   if (!arg2) {
7519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7520     return 0;
7521   }
7522   {
7523     try {
7524       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
7525     } catch (std::out_of_range& e) {
7526       {
7527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7528       };
7529     } catch (std::exception& e) {
7530       {
7531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7532       };
7533     } catch (Dali::DaliException e) {
7534       {
7535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7536       };
7537     } catch (...) {
7538       {
7539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7540       };
7541     }
7542   }
7543
7544   jresult = (void *)result;
7545   return jresult;
7546 }
7547
7548
7549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
7550   void * jresult ;
7551   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7552   Dali::Vector4 *arg2 = 0 ;
7553   Dali::Vector4 result;
7554
7555   arg1 = (Dali::Vector4 *)jarg1;
7556   arg2 = (Dali::Vector4 *)jarg2;
7557   if (!arg2) {
7558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7559     return 0;
7560   }
7561   {
7562     try {
7563       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
7564     } catch (std::out_of_range& e) {
7565       {
7566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7567       };
7568     } catch (std::exception& e) {
7569       {
7570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7571       };
7572     } catch (Dali::DaliException e) {
7573       {
7574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7575       };
7576     } catch (...) {
7577       {
7578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7579       };
7580     }
7581   }
7582
7583   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7584   return jresult;
7585 }
7586
7587
7588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
7589   void * jresult ;
7590   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7591   Dali::Vector4 *arg2 = 0 ;
7592   Dali::Vector4 *result = 0 ;
7593
7594   arg1 = (Dali::Vector4 *)jarg1;
7595   arg2 = (Dali::Vector4 *)jarg2;
7596   if (!arg2) {
7597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7598     return 0;
7599   }
7600   {
7601     try {
7602       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
7603     } catch (std::out_of_range& e) {
7604       {
7605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7606       };
7607     } catch (std::exception& e) {
7608       {
7609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7610       };
7611     } catch (Dali::DaliException e) {
7612       {
7613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7614       };
7615     } catch (...) {
7616       {
7617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7618       };
7619     }
7620   }
7621
7622   jresult = (void *)result;
7623   return jresult;
7624 }
7625
7626
7627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7628   void * jresult ;
7629   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7630   Dali::Vector4 *arg2 = 0 ;
7631   Dali::Vector4 result;
7632
7633   arg1 = (Dali::Vector4 *)jarg1;
7634   arg2 = (Dali::Vector4 *)jarg2;
7635   if (!arg2) {
7636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7637     return 0;
7638   }
7639   {
7640     try {
7641       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7642     } catch (std::out_of_range& e) {
7643       {
7644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7645       };
7646     } catch (std::exception& e) {
7647       {
7648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7649       };
7650     } catch (Dali::DaliException e) {
7651       {
7652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7653       };
7654     } catch (...) {
7655       {
7656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7657       };
7658     }
7659   }
7660
7661   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7662   return jresult;
7663 }
7664
7665
7666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7667   void * jresult ;
7668   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7669   float arg2 ;
7670   Dali::Vector4 result;
7671
7672   arg1 = (Dali::Vector4 *)jarg1;
7673   arg2 = (float)jarg2;
7674   {
7675     try {
7676       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7677     } catch (std::out_of_range& e) {
7678       {
7679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7680       };
7681     } catch (std::exception& e) {
7682       {
7683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7684       };
7685     } catch (Dali::DaliException e) {
7686       {
7687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7688       };
7689     } catch (...) {
7690       {
7691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7692       };
7693     }
7694   }
7695
7696   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7697   return jresult;
7698 }
7699
7700
7701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7702   void * jresult ;
7703   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7704   Dali::Vector4 *arg2 = 0 ;
7705   Dali::Vector4 *result = 0 ;
7706
7707   arg1 = (Dali::Vector4 *)jarg1;
7708   arg2 = (Dali::Vector4 *)jarg2;
7709   if (!arg2) {
7710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7711     return 0;
7712   }
7713   {
7714     try {
7715       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7716     } catch (std::out_of_range& e) {
7717       {
7718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7719       };
7720     } catch (std::exception& e) {
7721       {
7722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7723       };
7724     } catch (Dali::DaliException e) {
7725       {
7726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7727       };
7728     } catch (...) {
7729       {
7730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7731       };
7732     }
7733   }
7734
7735   jresult = (void *)result;
7736   return jresult;
7737 }
7738
7739
7740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7741   void * jresult ;
7742   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7743   float arg2 ;
7744   Dali::Vector4 *result = 0 ;
7745
7746   arg1 = (Dali::Vector4 *)jarg1;
7747   arg2 = (float)jarg2;
7748   {
7749     try {
7750       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7751     } catch (std::out_of_range& e) {
7752       {
7753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7754       };
7755     } catch (std::exception& e) {
7756       {
7757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7758       };
7759     } catch (Dali::DaliException e) {
7760       {
7761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7762       };
7763     } catch (...) {
7764       {
7765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7766       };
7767     }
7768   }
7769
7770   jresult = (void *)result;
7771   return jresult;
7772 }
7773
7774
7775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7776   void * jresult ;
7777   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7778   Dali::Vector4 *arg2 = 0 ;
7779   Dali::Vector4 result;
7780
7781   arg1 = (Dali::Vector4 *)jarg1;
7782   arg2 = (Dali::Vector4 *)jarg2;
7783   if (!arg2) {
7784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7785     return 0;
7786   }
7787   {
7788     try {
7789       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7790     } catch (std::out_of_range& e) {
7791       {
7792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7793       };
7794     } catch (std::exception& e) {
7795       {
7796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7797       };
7798     } catch (Dali::DaliException e) {
7799       {
7800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7801       };
7802     } catch (...) {
7803       {
7804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7805       };
7806     }
7807   }
7808
7809   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7810   return jresult;
7811 }
7812
7813
7814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7815   void * jresult ;
7816   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7817   float arg2 ;
7818   Dali::Vector4 result;
7819
7820   arg1 = (Dali::Vector4 *)jarg1;
7821   arg2 = (float)jarg2;
7822   {
7823     try {
7824       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7825     } catch (std::out_of_range& e) {
7826       {
7827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7828       };
7829     } catch (std::exception& e) {
7830       {
7831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7832       };
7833     } catch (Dali::DaliException e) {
7834       {
7835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7836       };
7837     } catch (...) {
7838       {
7839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7840       };
7841     }
7842   }
7843
7844   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7845   return jresult;
7846 }
7847
7848
7849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7850   void * jresult ;
7851   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7852   Dali::Vector4 *arg2 = 0 ;
7853   Dali::Vector4 *result = 0 ;
7854
7855   arg1 = (Dali::Vector4 *)jarg1;
7856   arg2 = (Dali::Vector4 *)jarg2;
7857   if (!arg2) {
7858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7859     return 0;
7860   }
7861   {
7862     try {
7863       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
7864     } catch (std::out_of_range& e) {
7865       {
7866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7867       };
7868     } catch (std::exception& e) {
7869       {
7870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7871       };
7872     } catch (Dali::DaliException e) {
7873       {
7874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7875       };
7876     } catch (...) {
7877       {
7878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7879       };
7880     }
7881   }
7882
7883   jresult = (void *)result;
7884   return jresult;
7885 }
7886
7887
7888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
7889   void * jresult ;
7890   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7891   float arg2 ;
7892   Dali::Vector4 *result = 0 ;
7893
7894   arg1 = (Dali::Vector4 *)jarg1;
7895   arg2 = (float)jarg2;
7896   {
7897     try {
7898       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
7899     } catch (std::out_of_range& e) {
7900       {
7901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7902       };
7903     } catch (std::exception& e) {
7904       {
7905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7906       };
7907     } catch (Dali::DaliException e) {
7908       {
7909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7910       };
7911     } catch (...) {
7912       {
7913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7914       };
7915     }
7916   }
7917
7918   jresult = (void *)result;
7919   return jresult;
7920 }
7921
7922
7923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
7924   void * jresult ;
7925   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7926   Dali::Vector4 result;
7927
7928   arg1 = (Dali::Vector4 *)jarg1;
7929   {
7930     try {
7931       result = ((Dali::Vector4 const *)arg1)->operator -();
7932     } catch (std::out_of_range& e) {
7933       {
7934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7935       };
7936     } catch (std::exception& e) {
7937       {
7938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7939       };
7940     } catch (Dali::DaliException e) {
7941       {
7942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7943       };
7944     } catch (...) {
7945       {
7946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7947       };
7948     }
7949   }
7950
7951   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7952   return jresult;
7953 }
7954
7955
7956 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
7957   unsigned int jresult ;
7958   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7959   Dali::Vector4 *arg2 = 0 ;
7960   bool result;
7961
7962   arg1 = (Dali::Vector4 *)jarg1;
7963   arg2 = (Dali::Vector4 *)jarg2;
7964   if (!arg2) {
7965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7966     return 0;
7967   }
7968   {
7969     try {
7970       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
7971     } catch (std::out_of_range& e) {
7972       {
7973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7974       };
7975     } catch (std::exception& e) {
7976       {
7977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7978       };
7979     } catch (Dali::DaliException e) {
7980       {
7981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7982       };
7983     } catch (...) {
7984       {
7985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7986       };
7987     }
7988   }
7989
7990   jresult = result;
7991   return jresult;
7992 }
7993
7994
7995 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
7996   unsigned int jresult ;
7997   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7998   Dali::Vector4 *arg2 = 0 ;
7999   bool result;
8000
8001   arg1 = (Dali::Vector4 *)jarg1;
8002   arg2 = (Dali::Vector4 *)jarg2;
8003   if (!arg2) {
8004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8005     return 0;
8006   }
8007   {
8008     try {
8009       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
8010     } catch (std::out_of_range& e) {
8011       {
8012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8013       };
8014     } catch (std::exception& e) {
8015       {
8016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8017       };
8018     } catch (Dali::DaliException e) {
8019       {
8020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8021       };
8022     } catch (...) {
8023       {
8024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8025       };
8026     }
8027   }
8028
8029   jresult = result;
8030   return jresult;
8031 }
8032
8033
8034 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
8035   float jresult ;
8036   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8037   unsigned int arg2 ;
8038   float *result = 0 ;
8039
8040   arg1 = (Dali::Vector4 *)jarg1;
8041   arg2 = (unsigned int)jarg2;
8042   {
8043     try {
8044       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
8045     } catch (std::out_of_range& e) {
8046       {
8047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8048       };
8049     } catch (std::exception& e) {
8050       {
8051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8052       };
8053     } catch (Dali::DaliException e) {
8054       {
8055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8056       };
8057     } catch (...) {
8058       {
8059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8060       };
8061     }
8062   }
8063
8064   jresult = *result;
8065   return jresult;
8066 }
8067
8068
8069 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
8070   float jresult ;
8071   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8072   Dali::Vector3 *arg2 = 0 ;
8073   float result;
8074
8075   arg1 = (Dali::Vector4 *)jarg1;
8076   arg2 = (Dali::Vector3 *)jarg2;
8077   if (!arg2) {
8078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8079     return 0;
8080   }
8081   {
8082     try {
8083       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
8084     } catch (std::out_of_range& e) {
8085       {
8086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8087       };
8088     } catch (std::exception& e) {
8089       {
8090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8091       };
8092     } catch (Dali::DaliException e) {
8093       {
8094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8095       };
8096     } catch (...) {
8097       {
8098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8099       };
8100     }
8101   }
8102
8103   jresult = result;
8104   return jresult;
8105 }
8106
8107
8108 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
8109   float jresult ;
8110   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8111   Dali::Vector4 *arg2 = 0 ;
8112   float result;
8113
8114   arg1 = (Dali::Vector4 *)jarg1;
8115   arg2 = (Dali::Vector4 *)jarg2;
8116   if (!arg2) {
8117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8118     return 0;
8119   }
8120   {
8121     try {
8122       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
8123     } catch (std::out_of_range& e) {
8124       {
8125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8126       };
8127     } catch (std::exception& e) {
8128       {
8129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8130       };
8131     } catch (Dali::DaliException e) {
8132       {
8133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8134       };
8135     } catch (...) {
8136       {
8137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8138       };
8139     }
8140   }
8141
8142   jresult = result;
8143   return jresult;
8144 }
8145
8146
8147 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
8148   float jresult ;
8149   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8150   Dali::Vector4 *arg2 = 0 ;
8151   float result;
8152
8153   arg1 = (Dali::Vector4 *)jarg1;
8154   arg2 = (Dali::Vector4 *)jarg2;
8155   if (!arg2) {
8156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8157     return 0;
8158   }
8159   {
8160     try {
8161       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
8162     } catch (std::out_of_range& e) {
8163       {
8164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8165       };
8166     } catch (std::exception& e) {
8167       {
8168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8169       };
8170     } catch (Dali::DaliException e) {
8171       {
8172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8173       };
8174     } catch (...) {
8175       {
8176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8177       };
8178     }
8179   }
8180
8181   jresult = result;
8182   return jresult;
8183 }
8184
8185
8186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
8187   void * jresult ;
8188   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8189   Dali::Vector4 *arg2 = 0 ;
8190   Dali::Vector4 result;
8191
8192   arg1 = (Dali::Vector4 *)jarg1;
8193   arg2 = (Dali::Vector4 *)jarg2;
8194   if (!arg2) {
8195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8196     return 0;
8197   }
8198   {
8199     try {
8200       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
8201     } catch (std::out_of_range& e) {
8202       {
8203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8204       };
8205     } catch (std::exception& e) {
8206       {
8207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8208       };
8209     } catch (Dali::DaliException e) {
8210       {
8211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8212       };
8213     } catch (...) {
8214       {
8215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8216       };
8217     }
8218   }
8219
8220   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8221   return jresult;
8222 }
8223
8224
8225 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
8226   float jresult ;
8227   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8228   float result;
8229
8230   arg1 = (Dali::Vector4 *)jarg1;
8231   {
8232     try {
8233       result = (float)((Dali::Vector4 const *)arg1)->Length();
8234     } catch (std::out_of_range& e) {
8235       {
8236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8237       };
8238     } catch (std::exception& e) {
8239       {
8240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8241       };
8242     } catch (Dali::DaliException e) {
8243       {
8244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8245       };
8246     } catch (...) {
8247       {
8248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8249       };
8250     }
8251   }
8252
8253   jresult = result;
8254   return jresult;
8255 }
8256
8257
8258 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
8259   float jresult ;
8260   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8261   float result;
8262
8263   arg1 = (Dali::Vector4 *)jarg1;
8264   {
8265     try {
8266       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
8267     } catch (std::out_of_range& e) {
8268       {
8269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8270       };
8271     } catch (std::exception& e) {
8272       {
8273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8274       };
8275     } catch (Dali::DaliException e) {
8276       {
8277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8278       };
8279     } catch (...) {
8280       {
8281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8282       };
8283     }
8284   }
8285
8286   jresult = result;
8287   return jresult;
8288 }
8289
8290
8291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
8292   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8293
8294   arg1 = (Dali::Vector4 *)jarg1;
8295   {
8296     try {
8297       (arg1)->Normalize();
8298     } catch (std::out_of_range& e) {
8299       {
8300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8301       };
8302     } catch (std::exception& e) {
8303       {
8304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8305       };
8306     } catch (Dali::DaliException e) {
8307       {
8308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8309       };
8310     } catch (...) {
8311       {
8312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8313       };
8314     }
8315   }
8316
8317 }
8318
8319
8320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
8321   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8322   Dali::Vector4 *arg2 = 0 ;
8323   Dali::Vector4 *arg3 = 0 ;
8324
8325   arg1 = (Dali::Vector4 *)jarg1;
8326   arg2 = (Dali::Vector4 *)jarg2;
8327   if (!arg2) {
8328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8329     return ;
8330   }
8331   arg3 = (Dali::Vector4 *)jarg3;
8332   if (!arg3) {
8333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8334     return ;
8335   }
8336   {
8337     try {
8338       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
8339     } catch (std::out_of_range& e) {
8340       {
8341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8342       };
8343     } catch (std::exception& e) {
8344       {
8345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8346       };
8347     } catch (Dali::DaliException e) {
8348       {
8349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8350       };
8351     } catch (...) {
8352       {
8353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8354       };
8355     }
8356   }
8357
8358 }
8359
8360
8361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
8362   void * jresult ;
8363   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8364   float *result = 0 ;
8365
8366   arg1 = (Dali::Vector4 *)jarg1;
8367   {
8368     try {
8369       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
8370     } catch (std::out_of_range& e) {
8371       {
8372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8373       };
8374     } catch (std::exception& e) {
8375       {
8376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8377       };
8378     } catch (Dali::DaliException e) {
8379       {
8380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8381       };
8382     } catch (...) {
8383       {
8384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8385       };
8386     }
8387   }
8388
8389   jresult = (void *)result;
8390   return jresult;
8391 }
8392
8393
8394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
8395   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8396   float arg2 ;
8397
8398   arg1 = (Dali::Vector4 *)jarg1;
8399   arg2 = (float)jarg2;
8400   if (arg1) (arg1)->x = arg2;
8401 }
8402
8403
8404 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
8405   float jresult ;
8406   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8407   float result;
8408
8409   arg1 = (Dali::Vector4 *)jarg1;
8410   result = (float) ((arg1)->x);
8411   jresult = result;
8412   return jresult;
8413 }
8414
8415
8416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
8417   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8418   float arg2 ;
8419
8420   arg1 = (Dali::Vector4 *)jarg1;
8421   arg2 = (float)jarg2;
8422   if (arg1) (arg1)->r = arg2;
8423 }
8424
8425
8426 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
8427   float jresult ;
8428   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8429   float result;
8430
8431   arg1 = (Dali::Vector4 *)jarg1;
8432   result = (float) ((arg1)->r);
8433   jresult = result;
8434   return jresult;
8435 }
8436
8437
8438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
8439   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8440   float arg2 ;
8441
8442   arg1 = (Dali::Vector4 *)jarg1;
8443   arg2 = (float)jarg2;
8444   if (arg1) (arg1)->s = arg2;
8445 }
8446
8447
8448 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
8449   float jresult ;
8450   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8451   float result;
8452
8453   arg1 = (Dali::Vector4 *)jarg1;
8454   result = (float) ((arg1)->s);
8455   jresult = result;
8456   return jresult;
8457 }
8458
8459
8460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
8461   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8462   float arg2 ;
8463
8464   arg1 = (Dali::Vector4 *)jarg1;
8465   arg2 = (float)jarg2;
8466   if (arg1) (arg1)->y = arg2;
8467 }
8468
8469
8470 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
8471   float jresult ;
8472   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8473   float result;
8474
8475   arg1 = (Dali::Vector4 *)jarg1;
8476   result = (float) ((arg1)->y);
8477   jresult = result;
8478   return jresult;
8479 }
8480
8481
8482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
8483   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8484   float arg2 ;
8485
8486   arg1 = (Dali::Vector4 *)jarg1;
8487   arg2 = (float)jarg2;
8488   if (arg1) (arg1)->g = arg2;
8489 }
8490
8491
8492 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
8493   float jresult ;
8494   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8495   float result;
8496
8497   arg1 = (Dali::Vector4 *)jarg1;
8498   result = (float) ((arg1)->g);
8499   jresult = result;
8500   return jresult;
8501 }
8502
8503
8504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
8505   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8506   float arg2 ;
8507
8508   arg1 = (Dali::Vector4 *)jarg1;
8509   arg2 = (float)jarg2;
8510   if (arg1) (arg1)->t = arg2;
8511 }
8512
8513
8514 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
8515   float jresult ;
8516   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8517   float result;
8518
8519   arg1 = (Dali::Vector4 *)jarg1;
8520   result = (float) ((arg1)->t);
8521   jresult = result;
8522   return jresult;
8523 }
8524
8525
8526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
8527   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8528   float arg2 ;
8529
8530   arg1 = (Dali::Vector4 *)jarg1;
8531   arg2 = (float)jarg2;
8532   if (arg1) (arg1)->z = arg2;
8533 }
8534
8535
8536 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
8537   float jresult ;
8538   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8539   float result;
8540
8541   arg1 = (Dali::Vector4 *)jarg1;
8542   result = (float) ((arg1)->z);
8543   jresult = result;
8544   return jresult;
8545 }
8546
8547
8548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
8549   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8550   float arg2 ;
8551
8552   arg1 = (Dali::Vector4 *)jarg1;
8553   arg2 = (float)jarg2;
8554   if (arg1) (arg1)->b = arg2;
8555 }
8556
8557
8558 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
8559   float jresult ;
8560   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8561   float result;
8562
8563   arg1 = (Dali::Vector4 *)jarg1;
8564   result = (float) ((arg1)->b);
8565   jresult = result;
8566   return jresult;
8567 }
8568
8569
8570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
8571   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8572   float arg2 ;
8573
8574   arg1 = (Dali::Vector4 *)jarg1;
8575   arg2 = (float)jarg2;
8576   if (arg1) (arg1)->p = arg2;
8577 }
8578
8579
8580 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
8581   float jresult ;
8582   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8583   float result;
8584
8585   arg1 = (Dali::Vector4 *)jarg1;
8586   result = (float) ((arg1)->p);
8587   jresult = result;
8588   return jresult;
8589 }
8590
8591
8592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
8593   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8594   float arg2 ;
8595
8596   arg1 = (Dali::Vector4 *)jarg1;
8597   arg2 = (float)jarg2;
8598   if (arg1) (arg1)->w = arg2;
8599 }
8600
8601
8602 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
8603   float jresult ;
8604   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8605   float result;
8606
8607   arg1 = (Dali::Vector4 *)jarg1;
8608   result = (float) ((arg1)->w);
8609   jresult = result;
8610   return jresult;
8611 }
8612
8613
8614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
8615   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8616   float arg2 ;
8617
8618   arg1 = (Dali::Vector4 *)jarg1;
8619   arg2 = (float)jarg2;
8620   if (arg1) (arg1)->a = arg2;
8621 }
8622
8623
8624 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
8625   float jresult ;
8626   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8627   float result;
8628
8629   arg1 = (Dali::Vector4 *)jarg1;
8630   result = (float) ((arg1)->a);
8631   jresult = result;
8632   return jresult;
8633 }
8634
8635
8636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
8637   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8638   float arg2 ;
8639
8640   arg1 = (Dali::Vector4 *)jarg1;
8641   arg2 = (float)jarg2;
8642   if (arg1) (arg1)->q = arg2;
8643 }
8644
8645
8646 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
8647   float jresult ;
8648   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8649   float result;
8650
8651   arg1 = (Dali::Vector4 *)jarg1;
8652   result = (float) ((arg1)->q);
8653   jresult = result;
8654   return jresult;
8655 }
8656
8657
8658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
8659   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8660
8661   arg1 = (Dali::Vector4 *)jarg1;
8662   {
8663     try {
8664       delete arg1;
8665     } catch (std::out_of_range& e) {
8666       {
8667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8668       };
8669     } catch (std::exception& e) {
8670       {
8671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8672       };
8673     } catch (Dali::DaliException e) {
8674       {
8675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8676       };
8677     } catch (...) {
8678       {
8679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8680       };
8681     }
8682   }
8683
8684 }
8685
8686
8687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
8688   void * jresult ;
8689   Dali::Vector4 *arg1 = 0 ;
8690   Dali::Vector4 *arg2 = 0 ;
8691   Dali::Vector4 result;
8692
8693   arg1 = (Dali::Vector4 *)jarg1;
8694   if (!arg1) {
8695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8696     return 0;
8697   }
8698   arg2 = (Dali::Vector4 *)jarg2;
8699   if (!arg2) {
8700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8701     return 0;
8702   }
8703   {
8704     try {
8705       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8706     } catch (std::out_of_range& e) {
8707       {
8708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8709       };
8710     } catch (std::exception& e) {
8711       {
8712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8713       };
8714     } catch (Dali::DaliException e) {
8715       {
8716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8717       };
8718     } catch (...) {
8719       {
8720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8721       };
8722     }
8723   }
8724
8725   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8726   return jresult;
8727 }
8728
8729
8730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8731   void * jresult ;
8732   Dali::Vector4 *arg1 = 0 ;
8733   Dali::Vector4 *arg2 = 0 ;
8734   Dali::Vector4 result;
8735
8736   arg1 = (Dali::Vector4 *)jarg1;
8737   if (!arg1) {
8738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8739     return 0;
8740   }
8741   arg2 = (Dali::Vector4 *)jarg2;
8742   if (!arg2) {
8743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8744     return 0;
8745   }
8746   {
8747     try {
8748       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8749     } catch (std::out_of_range& e) {
8750       {
8751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8752       };
8753     } catch (std::exception& e) {
8754       {
8755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8756       };
8757     } catch (Dali::DaliException e) {
8758       {
8759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8760       };
8761     } catch (...) {
8762       {
8763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8764       };
8765     }
8766   }
8767
8768   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8769   return jresult;
8770 }
8771
8772
8773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8774   void * jresult ;
8775   Dali::Vector4 *arg1 = 0 ;
8776   float *arg2 = 0 ;
8777   float *arg3 = 0 ;
8778   float temp2 ;
8779   float temp3 ;
8780   Dali::Vector4 result;
8781
8782   arg1 = (Dali::Vector4 *)jarg1;
8783   if (!arg1) {
8784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8785     return 0;
8786   }
8787   temp2 = (float)jarg2;
8788   arg2 = &temp2;
8789   temp3 = (float)jarg3;
8790   arg3 = &temp3;
8791   {
8792     try {
8793       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8794     } catch (std::out_of_range& e) {
8795       {
8796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8797       };
8798     } catch (std::exception& e) {
8799       {
8800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8801       };
8802     } catch (Dali::DaliException e) {
8803       {
8804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8805       };
8806     } catch (...) {
8807       {
8808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8809       };
8810     }
8811   }
8812
8813   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8814   return jresult;
8815 }
8816
8817
8818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8819   void * jresult ;
8820   Dali::Uint16Pair *result = 0 ;
8821
8822   {
8823     try {
8824       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8825     } catch (std::out_of_range& e) {
8826       {
8827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8828       };
8829     } catch (std::exception& e) {
8830       {
8831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8832       };
8833     } catch (Dali::DaliException e) {
8834       {
8835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8836       };
8837     } catch (...) {
8838       {
8839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8840       };
8841     }
8842   }
8843
8844   jresult = (void *)result;
8845   return jresult;
8846 }
8847
8848
8849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8850   void * jresult ;
8851   uint32_t arg1 ;
8852   uint32_t arg2 ;
8853   Dali::Uint16Pair *result = 0 ;
8854
8855   arg1 = (uint32_t)jarg1;
8856   arg2 = (uint32_t)jarg2;
8857   {
8858     try {
8859       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8860     } catch (std::out_of_range& e) {
8861       {
8862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8863       };
8864     } catch (std::exception& e) {
8865       {
8866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8867       };
8868     } catch (Dali::DaliException e) {
8869       {
8870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8871       };
8872     } catch (...) {
8873       {
8874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8875       };
8876     }
8877   }
8878
8879   jresult = (void *)result;
8880   return jresult;
8881 }
8882
8883
8884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
8885   void * jresult ;
8886   Dali::Uint16Pair *arg1 = 0 ;
8887   Dali::Uint16Pair *result = 0 ;
8888
8889   arg1 = (Dali::Uint16Pair *)jarg1;
8890   if (!arg1) {
8891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8892     return 0;
8893   }
8894   {
8895     try {
8896       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
8897     } catch (std::out_of_range& e) {
8898       {
8899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8900       };
8901     } catch (std::exception& e) {
8902       {
8903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8904       };
8905     } catch (Dali::DaliException e) {
8906       {
8907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8908       };
8909     } catch (...) {
8910       {
8911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8912       };
8913     }
8914   }
8915
8916   jresult = (void *)result;
8917   return jresult;
8918 }
8919
8920
8921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
8922   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8923   uint16_t arg2 ;
8924
8925   arg1 = (Dali::Uint16Pair *)jarg1;
8926   arg2 = (uint16_t)jarg2;
8927   {
8928     try {
8929       (arg1)->SetWidth(arg2);
8930     } catch (std::out_of_range& e) {
8931       {
8932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8933       };
8934     } catch (std::exception& e) {
8935       {
8936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8937       };
8938     } catch (Dali::DaliException e) {
8939       {
8940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8941       };
8942     } catch (...) {
8943       {
8944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8945       };
8946     }
8947   }
8948
8949 }
8950
8951
8952 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
8953   unsigned short jresult ;
8954   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8955   uint16_t result;
8956
8957   arg1 = (Dali::Uint16Pair *)jarg1;
8958   {
8959     try {
8960       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
8961     } catch (std::out_of_range& e) {
8962       {
8963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8964       };
8965     } catch (std::exception& e) {
8966       {
8967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8968       };
8969     } catch (Dali::DaliException e) {
8970       {
8971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8972       };
8973     } catch (...) {
8974       {
8975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8976       };
8977     }
8978   }
8979
8980   jresult = result;
8981   return jresult;
8982 }
8983
8984
8985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
8986   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8987   uint16_t arg2 ;
8988
8989   arg1 = (Dali::Uint16Pair *)jarg1;
8990   arg2 = (uint16_t)jarg2;
8991   {
8992     try {
8993       (arg1)->SetHeight(arg2);
8994     } catch (std::out_of_range& e) {
8995       {
8996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8997       };
8998     } catch (std::exception& e) {
8999       {
9000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9001       };
9002     } catch (Dali::DaliException e) {
9003       {
9004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9005       };
9006     } catch (...) {
9007       {
9008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9009       };
9010     }
9011   }
9012
9013 }
9014
9015
9016 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
9017   unsigned short jresult ;
9018   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9019   uint16_t result;
9020
9021   arg1 = (Dali::Uint16Pair *)jarg1;
9022   {
9023     try {
9024       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
9025     } catch (std::out_of_range& e) {
9026       {
9027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9028       };
9029     } catch (std::exception& e) {
9030       {
9031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9032       };
9033     } catch (Dali::DaliException e) {
9034       {
9035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9036       };
9037     } catch (...) {
9038       {
9039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9040       };
9041     }
9042   }
9043
9044   jresult = result;
9045   return jresult;
9046 }
9047
9048
9049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
9050   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9051   uint16_t arg2 ;
9052
9053   arg1 = (Dali::Uint16Pair *)jarg1;
9054   arg2 = (uint16_t)jarg2;
9055   {
9056     try {
9057       (arg1)->SetX(arg2);
9058     } catch (std::out_of_range& e) {
9059       {
9060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9061       };
9062     } catch (std::exception& e) {
9063       {
9064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9065       };
9066     } catch (Dali::DaliException e) {
9067       {
9068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9069       };
9070     } catch (...) {
9071       {
9072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9073       };
9074     }
9075   }
9076
9077 }
9078
9079
9080 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
9081   unsigned short jresult ;
9082   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9083   uint16_t result;
9084
9085   arg1 = (Dali::Uint16Pair *)jarg1;
9086   {
9087     try {
9088       result = ((Dali::Uint16Pair const *)arg1)->GetX();
9089     } catch (std::out_of_range& e) {
9090       {
9091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9092       };
9093     } catch (std::exception& e) {
9094       {
9095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9096       };
9097     } catch (Dali::DaliException e) {
9098       {
9099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9100       };
9101     } catch (...) {
9102       {
9103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9104       };
9105     }
9106   }
9107
9108   jresult = result;
9109   return jresult;
9110 }
9111
9112
9113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
9114   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9115   uint16_t arg2 ;
9116
9117   arg1 = (Dali::Uint16Pair *)jarg1;
9118   arg2 = (uint16_t)jarg2;
9119   {
9120     try {
9121       (arg1)->SetY(arg2);
9122     } catch (std::out_of_range& e) {
9123       {
9124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9125       };
9126     } catch (std::exception& e) {
9127       {
9128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9129       };
9130     } catch (Dali::DaliException e) {
9131       {
9132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9133       };
9134     } catch (...) {
9135       {
9136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9137       };
9138     }
9139   }
9140
9141 }
9142
9143
9144 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
9145   unsigned short jresult ;
9146   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9147   uint16_t result;
9148
9149   arg1 = (Dali::Uint16Pair *)jarg1;
9150   {
9151     try {
9152       result = ((Dali::Uint16Pair const *)arg1)->GetY();
9153     } catch (std::out_of_range& e) {
9154       {
9155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9156       };
9157     } catch (std::exception& e) {
9158       {
9159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9160       };
9161     } catch (Dali::DaliException e) {
9162       {
9163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9164       };
9165     } catch (...) {
9166       {
9167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9168       };
9169     }
9170   }
9171
9172   jresult = result;
9173   return jresult;
9174 }
9175
9176
9177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
9178   void * jresult ;
9179   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9180   Dali::Uint16Pair *arg2 = 0 ;
9181   Dali::Uint16Pair *result = 0 ;
9182
9183   arg1 = (Dali::Uint16Pair *)jarg1;
9184   arg2 = (Dali::Uint16Pair *)jarg2;
9185   if (!arg2) {
9186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9187     return 0;
9188   }
9189   {
9190     try {
9191       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
9192     } catch (std::out_of_range& e) {
9193       {
9194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9195       };
9196     } catch (std::exception& e) {
9197       {
9198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9199       };
9200     } catch (Dali::DaliException e) {
9201       {
9202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9203       };
9204     } catch (...) {
9205       {
9206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9207       };
9208     }
9209   }
9210
9211   jresult = (void *)result;
9212   return jresult;
9213 }
9214
9215
9216 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
9217   unsigned int jresult ;
9218   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9219   Dali::Uint16Pair *arg2 = 0 ;
9220   bool result;
9221
9222   arg1 = (Dali::Uint16Pair *)jarg1;
9223   arg2 = (Dali::Uint16Pair *)jarg2;
9224   if (!arg2) {
9225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9226     return 0;
9227   }
9228   {
9229     try {
9230       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
9231     } catch (std::out_of_range& e) {
9232       {
9233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9234       };
9235     } catch (std::exception& e) {
9236       {
9237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9238       };
9239     } catch (Dali::DaliException e) {
9240       {
9241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9242       };
9243     } catch (...) {
9244       {
9245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9246       };
9247     }
9248   }
9249
9250   jresult = result;
9251   return jresult;
9252 }
9253
9254
9255 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
9256   unsigned int jresult ;
9257   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9258   Dali::Uint16Pair *arg2 = 0 ;
9259   bool result;
9260
9261   arg1 = (Dali::Uint16Pair *)jarg1;
9262   arg2 = (Dali::Uint16Pair *)jarg2;
9263   if (!arg2) {
9264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9265     return 0;
9266   }
9267   {
9268     try {
9269       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
9270     } catch (std::out_of_range& e) {
9271       {
9272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9273       };
9274     } catch (std::exception& e) {
9275       {
9276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9277       };
9278     } catch (Dali::DaliException e) {
9279       {
9280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9281       };
9282     } catch (...) {
9283       {
9284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9285       };
9286     }
9287   }
9288
9289   jresult = result;
9290   return jresult;
9291 }
9292
9293
9294 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
9295   unsigned int jresult ;
9296   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9297   Dali::Uint16Pair *arg2 = 0 ;
9298   bool result;
9299
9300   arg1 = (Dali::Uint16Pair *)jarg1;
9301   arg2 = (Dali::Uint16Pair *)jarg2;
9302   if (!arg2) {
9303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9304     return 0;
9305   }
9306   {
9307     try {
9308       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
9309     } catch (std::out_of_range& e) {
9310       {
9311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9312       };
9313     } catch (std::exception& e) {
9314       {
9315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9316       };
9317     } catch (Dali::DaliException e) {
9318       {
9319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9320       };
9321     } catch (...) {
9322       {
9323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9324       };
9325     }
9326   }
9327
9328   jresult = result;
9329   return jresult;
9330 }
9331
9332
9333 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
9334   unsigned int jresult ;
9335   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9336   Dali::Uint16Pair *arg2 = 0 ;
9337   bool result;
9338
9339   arg1 = (Dali::Uint16Pair *)jarg1;
9340   arg2 = (Dali::Uint16Pair *)jarg2;
9341   if (!arg2) {
9342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9343     return 0;
9344   }
9345   {
9346     try {
9347       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
9348     } catch (std::out_of_range& e) {
9349       {
9350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9351       };
9352     } catch (std::exception& e) {
9353       {
9354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9355       };
9356     } catch (Dali::DaliException e) {
9357       {
9358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9359       };
9360     } catch (...) {
9361       {
9362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9363       };
9364     }
9365   }
9366
9367   jresult = result;
9368   return jresult;
9369 }
9370
9371
9372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
9373   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9374
9375   arg1 = (Dali::Uint16Pair *)jarg1;
9376   {
9377     try {
9378       delete arg1;
9379     } catch (std::out_of_range& e) {
9380       {
9381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9382       };
9383     } catch (std::exception& e) {
9384       {
9385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9386       };
9387     } catch (Dali::DaliException e) {
9388       {
9389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9390       };
9391     } catch (...) {
9392       {
9393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9394       };
9395     }
9396   }
9397
9398 }
9399
9400
9401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
9402   void * jresult ;
9403   Dali::Degree *result = 0 ;
9404
9405   {
9406     try {
9407       result = (Dali::Degree *)new Dali::Degree();
9408     } catch (std::out_of_range& e) {
9409       {
9410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9411       };
9412     } catch (std::exception& e) {
9413       {
9414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9415       };
9416     } catch (Dali::DaliException e) {
9417       {
9418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9419       };
9420     } catch (...) {
9421       {
9422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9423       };
9424     }
9425   }
9426
9427   jresult = (void *)result;
9428   return jresult;
9429 }
9430
9431
9432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
9433   void * jresult ;
9434   float arg1 ;
9435   Dali::Degree *result = 0 ;
9436
9437   arg1 = (float)jarg1;
9438   {
9439     try {
9440       result = (Dali::Degree *)new Dali::Degree(arg1);
9441     } catch (std::out_of_range& e) {
9442       {
9443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9444       };
9445     } catch (std::exception& e) {
9446       {
9447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9448       };
9449     } catch (Dali::DaliException e) {
9450       {
9451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9452       };
9453     } catch (...) {
9454       {
9455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9456       };
9457     }
9458   }
9459
9460   jresult = (void *)result;
9461   return jresult;
9462 }
9463
9464
9465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
9466   void * jresult ;
9467   Dali::Radian arg1 ;
9468   Dali::Radian *argp1 ;
9469   Dali::Degree *result = 0 ;
9470
9471   argp1 = (Dali::Radian *)jarg1;
9472   if (!argp1) {
9473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9474     return 0;
9475   }
9476   arg1 = *argp1;
9477   {
9478     try {
9479       result = (Dali::Degree *)new Dali::Degree(arg1);
9480     } catch (std::out_of_range& e) {
9481       {
9482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9483       };
9484     } catch (std::exception& e) {
9485       {
9486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9487       };
9488     } catch (Dali::DaliException e) {
9489       {
9490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9491       };
9492     } catch (...) {
9493       {
9494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9495       };
9496     }
9497   }
9498
9499   jresult = (void *)result;
9500   return jresult;
9501 }
9502
9503
9504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
9505   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9506   float arg2 ;
9507
9508   arg1 = (Dali::Degree *)jarg1;
9509   arg2 = (float)jarg2;
9510   if (arg1) (arg1)->degree = arg2;
9511 }
9512
9513
9514 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
9515   float jresult ;
9516   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9517   float result;
9518
9519   arg1 = (Dali::Degree *)jarg1;
9520   result = (float) ((arg1)->degree);
9521   jresult = result;
9522   return jresult;
9523 }
9524
9525
9526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
9527   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9528
9529   arg1 = (Dali::Degree *)jarg1;
9530   {
9531     try {
9532       delete arg1;
9533     } catch (std::out_of_range& e) {
9534       {
9535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9536       };
9537     } catch (std::exception& e) {
9538       {
9539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9540       };
9541     } catch (Dali::DaliException e) {
9542       {
9543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9544       };
9545     } catch (...) {
9546       {
9547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9548       };
9549     }
9550   }
9551
9552 }
9553
9554
9555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
9556   void * jresult ;
9557   Dali::Radian *result = 0 ;
9558
9559   result = (Dali::Radian *)&Dali::ANGLE_360;
9560   jresult = (void *)result;
9561   return jresult;
9562 }
9563
9564
9565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
9566   void * jresult ;
9567   Dali::Radian *result = 0 ;
9568
9569   result = (Dali::Radian *)&Dali::ANGLE_315;
9570   jresult = (void *)result;
9571   return jresult;
9572 }
9573
9574
9575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
9576   void * jresult ;
9577   Dali::Radian *result = 0 ;
9578
9579   result = (Dali::Radian *)&Dali::ANGLE_270;
9580   jresult = (void *)result;
9581   return jresult;
9582 }
9583
9584
9585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
9586   void * jresult ;
9587   Dali::Radian *result = 0 ;
9588
9589   result = (Dali::Radian *)&Dali::ANGLE_225;
9590   jresult = (void *)result;
9591   return jresult;
9592 }
9593
9594
9595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
9596   void * jresult ;
9597   Dali::Radian *result = 0 ;
9598
9599   result = (Dali::Radian *)&Dali::ANGLE_180;
9600   jresult = (void *)result;
9601   return jresult;
9602 }
9603
9604
9605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
9606   void * jresult ;
9607   Dali::Radian *result = 0 ;
9608
9609   result = (Dali::Radian *)&Dali::ANGLE_135;
9610   jresult = (void *)result;
9611   return jresult;
9612 }
9613
9614
9615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
9616   void * jresult ;
9617   Dali::Radian *result = 0 ;
9618
9619   result = (Dali::Radian *)&Dali::ANGLE_120;
9620   jresult = (void *)result;
9621   return jresult;
9622 }
9623
9624
9625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
9626   void * jresult ;
9627   Dali::Radian *result = 0 ;
9628
9629   result = (Dali::Radian *)&Dali::ANGLE_90;
9630   jresult = (void *)result;
9631   return jresult;
9632 }
9633
9634
9635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
9636   void * jresult ;
9637   Dali::Radian *result = 0 ;
9638
9639   result = (Dali::Radian *)&Dali::ANGLE_60;
9640   jresult = (void *)result;
9641   return jresult;
9642 }
9643
9644
9645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
9646   void * jresult ;
9647   Dali::Radian *result = 0 ;
9648
9649   result = (Dali::Radian *)&Dali::ANGLE_45;
9650   jresult = (void *)result;
9651   return jresult;
9652 }
9653
9654
9655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
9656   void * jresult ;
9657   Dali::Radian *result = 0 ;
9658
9659   result = (Dali::Radian *)&Dali::ANGLE_30;
9660   jresult = (void *)result;
9661   return jresult;
9662 }
9663
9664
9665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
9666   void * jresult ;
9667   Dali::Radian *result = 0 ;
9668
9669   result = (Dali::Radian *)&Dali::ANGLE_0;
9670   jresult = (void *)result;
9671   return jresult;
9672 }
9673
9674
9675 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
9676   unsigned int jresult ;
9677   Dali::Degree *arg1 = 0 ;
9678   Dali::Degree *arg2 = 0 ;
9679   bool result;
9680
9681   arg1 = (Dali::Degree *)jarg1;
9682   if (!arg1) {
9683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9684     return 0;
9685   }
9686   arg2 = (Dali::Degree *)jarg2;
9687   if (!arg2) {
9688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9689     return 0;
9690   }
9691   {
9692     try {
9693       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9694     } catch (std::out_of_range& e) {
9695       {
9696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9697       };
9698     } catch (std::exception& e) {
9699       {
9700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9701       };
9702     } catch (Dali::DaliException e) {
9703       {
9704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9705       };
9706     } catch (...) {
9707       {
9708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9709       };
9710     }
9711   }
9712
9713   jresult = result;
9714   return jresult;
9715 }
9716
9717
9718 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
9719   unsigned int jresult ;
9720   Dali::Degree *arg1 = 0 ;
9721   Dali::Degree *arg2 = 0 ;
9722   bool result;
9723
9724   arg1 = (Dali::Degree *)jarg1;
9725   if (!arg1) {
9726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9727     return 0;
9728   }
9729   arg2 = (Dali::Degree *)jarg2;
9730   if (!arg2) {
9731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9732     return 0;
9733   }
9734   {
9735     try {
9736       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9737     } catch (std::out_of_range& e) {
9738       {
9739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9740       };
9741     } catch (std::exception& e) {
9742       {
9743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9744       };
9745     } catch (Dali::DaliException e) {
9746       {
9747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9748       };
9749     } catch (...) {
9750       {
9751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9752       };
9753     }
9754   }
9755
9756   jresult = result;
9757   return jresult;
9758 }
9759
9760
9761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
9762   void * jresult ;
9763   Dali::Degree arg1 ;
9764   float arg2 ;
9765   float arg3 ;
9766   Dali::Degree *argp1 ;
9767   Dali::Degree result;
9768
9769   argp1 = (Dali::Degree *)jarg1;
9770   if (!argp1) {
9771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9772     return 0;
9773   }
9774   arg1 = *argp1;
9775   arg2 = (float)jarg2;
9776   arg3 = (float)jarg3;
9777   {
9778     try {
9779       result = Dali::Clamp(arg1,arg2,arg3);
9780     } catch (std::out_of_range& e) {
9781       {
9782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9783       };
9784     } catch (std::exception& e) {
9785       {
9786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9787       };
9788     } catch (Dali::DaliException e) {
9789       {
9790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9791       };
9792     } catch (...) {
9793       {
9794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9795       };
9796     }
9797   }
9798
9799   jresult = new Dali::Degree((const Dali::Degree &)result);
9800   return jresult;
9801 }
9802
9803
9804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
9805   void * jresult ;
9806   Dali::Radian *result = 0 ;
9807
9808   {
9809     try {
9810       result = (Dali::Radian *)new Dali::Radian();
9811     } catch (std::out_of_range& e) {
9812       {
9813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9814       };
9815     } catch (std::exception& e) {
9816       {
9817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9818       };
9819     } catch (Dali::DaliException e) {
9820       {
9821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9822       };
9823     } catch (...) {
9824       {
9825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9826       };
9827     }
9828   }
9829
9830   jresult = (void *)result;
9831   return jresult;
9832 }
9833
9834
9835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
9836   void * jresult ;
9837   float arg1 ;
9838   Dali::Radian *result = 0 ;
9839
9840   arg1 = (float)jarg1;
9841   {
9842     try {
9843       result = (Dali::Radian *)new Dali::Radian(arg1);
9844     } catch (std::out_of_range& e) {
9845       {
9846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9847       };
9848     } catch (std::exception& e) {
9849       {
9850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9851       };
9852     } catch (Dali::DaliException e) {
9853       {
9854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9855       };
9856     } catch (...) {
9857       {
9858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9859       };
9860     }
9861   }
9862
9863   jresult = (void *)result;
9864   return jresult;
9865 }
9866
9867
9868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
9869   void * jresult ;
9870   Dali::Degree arg1 ;
9871   Dali::Degree *argp1 ;
9872   Dali::Radian *result = 0 ;
9873
9874   argp1 = (Dali::Degree *)jarg1;
9875   if (!argp1) {
9876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9877     return 0;
9878   }
9879   arg1 = *argp1;
9880   {
9881     try {
9882       result = (Dali::Radian *)new Dali::Radian(arg1);
9883     } catch (std::out_of_range& e) {
9884       {
9885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9886       };
9887     } catch (std::exception& e) {
9888       {
9889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9890       };
9891     } catch (Dali::DaliException e) {
9892       {
9893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9894       };
9895     } catch (...) {
9896       {
9897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9898       };
9899     }
9900   }
9901
9902   jresult = (void *)result;
9903   return jresult;
9904 }
9905
9906
9907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
9908   void * jresult ;
9909   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9910   float arg2 ;
9911   Dali::Radian *result = 0 ;
9912
9913   arg1 = (Dali::Radian *)jarg1;
9914   arg2 = (float)jarg2;
9915   {
9916     try {
9917       result = (Dali::Radian *) &(arg1)->operator =(arg2);
9918     } catch (std::out_of_range& e) {
9919       {
9920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9921       };
9922     } catch (std::exception& e) {
9923       {
9924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9925       };
9926     } catch (Dali::DaliException e) {
9927       {
9928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9929       };
9930     } catch (...) {
9931       {
9932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9933       };
9934     }
9935   }
9936
9937   jresult = (void *)result;
9938   return jresult;
9939 }
9940
9941
9942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
9943   void * jresult ;
9944   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9945   Dali::Degree arg2 ;
9946   Dali::Degree *argp2 ;
9947   Dali::Radian *result = 0 ;
9948
9949   arg1 = (Dali::Radian *)jarg1;
9950   argp2 = (Dali::Degree *)jarg2;
9951   if (!argp2) {
9952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9953     return 0;
9954   }
9955   arg2 = *argp2;
9956   {
9957     try {
9958       result = (Dali::Radian *) &(arg1)->operator =(arg2);
9959     } catch (std::out_of_range& e) {
9960       {
9961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9962       };
9963     } catch (std::exception& e) {
9964       {
9965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9966       };
9967     } catch (Dali::DaliException e) {
9968       {
9969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9970       };
9971     } catch (...) {
9972       {
9973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9974       };
9975     }
9976   }
9977
9978   jresult = (void *)result;
9979   return jresult;
9980 }
9981
9982
9983 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
9984   float jresult ;
9985   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9986   float result;
9987
9988   arg1 = (Dali::Radian *)jarg1;
9989   {
9990     try {
9991       result = (float)((Dali::Radian const *)arg1)->operator float();
9992     } catch (std::out_of_range& e) {
9993       {
9994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9995       };
9996     } catch (std::exception& e) {
9997       {
9998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9999       };
10000     } catch (Dali::DaliException e) {
10001       {
10002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10003       };
10004     } catch (...) {
10005       {
10006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10007       };
10008     }
10009   }
10010
10011   jresult = result;
10012   return jresult;
10013 }
10014
10015
10016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
10017   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10018   float arg2 ;
10019
10020   arg1 = (Dali::Radian *)jarg1;
10021   arg2 = (float)jarg2;
10022   if (arg1) (arg1)->radian = arg2;
10023 }
10024
10025
10026 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
10027   float jresult ;
10028   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10029   float result;
10030
10031   arg1 = (Dali::Radian *)jarg1;
10032   result = (float) ((arg1)->radian);
10033   jresult = result;
10034   return jresult;
10035 }
10036
10037
10038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
10039   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10040
10041   arg1 = (Dali::Radian *)jarg1;
10042   {
10043     try {
10044       delete arg1;
10045     } catch (std::out_of_range& e) {
10046       {
10047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10048       };
10049     } catch (std::exception& e) {
10050       {
10051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10052       };
10053     } catch (Dali::DaliException e) {
10054       {
10055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10056       };
10057     } catch (...) {
10058       {
10059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10060       };
10061     }
10062   }
10063
10064 }
10065
10066
10067 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
10068   unsigned int jresult ;
10069   Dali::Radian arg1 ;
10070   Dali::Radian arg2 ;
10071   Dali::Radian *argp1 ;
10072   Dali::Radian *argp2 ;
10073   bool result;
10074
10075   argp1 = (Dali::Radian *)jarg1;
10076   if (!argp1) {
10077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10078     return 0;
10079   }
10080   arg1 = *argp1;
10081   argp2 = (Dali::Radian *)jarg2;
10082   if (!argp2) {
10083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10084     return 0;
10085   }
10086   arg2 = *argp2;
10087   {
10088     try {
10089       result = (bool)Dali::operator ==(arg1,arg2);
10090     } catch (std::out_of_range& e) {
10091       {
10092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10093       };
10094     } catch (std::exception& e) {
10095       {
10096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10097       };
10098     } catch (Dali::DaliException e) {
10099       {
10100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10101       };
10102     } catch (...) {
10103       {
10104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10105       };
10106     }
10107   }
10108
10109   jresult = result;
10110   return jresult;
10111 }
10112
10113
10114 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
10115   unsigned int jresult ;
10116   Dali::Radian arg1 ;
10117   Dali::Radian arg2 ;
10118   Dali::Radian *argp1 ;
10119   Dali::Radian *argp2 ;
10120   bool result;
10121
10122   argp1 = (Dali::Radian *)jarg1;
10123   if (!argp1) {
10124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10125     return 0;
10126   }
10127   arg1 = *argp1;
10128   argp2 = (Dali::Radian *)jarg2;
10129   if (!argp2) {
10130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10131     return 0;
10132   }
10133   arg2 = *argp2;
10134   {
10135     try {
10136       result = (bool)Dali::operator !=(arg1,arg2);
10137     } catch (std::out_of_range& e) {
10138       {
10139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10140       };
10141     } catch (std::exception& e) {
10142       {
10143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10144       };
10145     } catch (Dali::DaliException e) {
10146       {
10147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10148       };
10149     } catch (...) {
10150       {
10151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10152       };
10153     }
10154   }
10155
10156   jresult = result;
10157   return jresult;
10158 }
10159
10160
10161 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
10162   unsigned int jresult ;
10163   Dali::Radian arg1 ;
10164   Dali::Degree arg2 ;
10165   Dali::Radian *argp1 ;
10166   Dali::Degree *argp2 ;
10167   bool result;
10168
10169   argp1 = (Dali::Radian *)jarg1;
10170   if (!argp1) {
10171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10172     return 0;
10173   }
10174   arg1 = *argp1;
10175   argp2 = (Dali::Degree *)jarg2;
10176   if (!argp2) {
10177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10178     return 0;
10179   }
10180   arg2 = *argp2;
10181   {
10182     try {
10183       result = (bool)Dali::operator ==(arg1,arg2);
10184     } catch (std::out_of_range& e) {
10185       {
10186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10187       };
10188     } catch (std::exception& e) {
10189       {
10190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10191       };
10192     } catch (Dali::DaliException e) {
10193       {
10194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10195       };
10196     } catch (...) {
10197       {
10198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10199       };
10200     }
10201   }
10202
10203   jresult = result;
10204   return jresult;
10205 }
10206
10207
10208 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
10209   unsigned int jresult ;
10210   Dali::Radian arg1 ;
10211   Dali::Degree arg2 ;
10212   Dali::Radian *argp1 ;
10213   Dali::Degree *argp2 ;
10214   bool result;
10215
10216   argp1 = (Dali::Radian *)jarg1;
10217   if (!argp1) {
10218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10219     return 0;
10220   }
10221   arg1 = *argp1;
10222   argp2 = (Dali::Degree *)jarg2;
10223   if (!argp2) {
10224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10225     return 0;
10226   }
10227   arg2 = *argp2;
10228   {
10229     try {
10230       result = (bool)Dali::operator !=(arg1,arg2);
10231     } catch (std::out_of_range& e) {
10232       {
10233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10234       };
10235     } catch (std::exception& e) {
10236       {
10237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10238       };
10239     } catch (Dali::DaliException e) {
10240       {
10241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10242       };
10243     } catch (...) {
10244       {
10245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10246       };
10247     }
10248   }
10249
10250   jresult = result;
10251   return jresult;
10252 }
10253
10254
10255 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
10256   unsigned int jresult ;
10257   Dali::Degree arg1 ;
10258   Dali::Radian arg2 ;
10259   Dali::Degree *argp1 ;
10260   Dali::Radian *argp2 ;
10261   bool result;
10262
10263   argp1 = (Dali::Degree *)jarg1;
10264   if (!argp1) {
10265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10266     return 0;
10267   }
10268   arg1 = *argp1;
10269   argp2 = (Dali::Radian *)jarg2;
10270   if (!argp2) {
10271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10272     return 0;
10273   }
10274   arg2 = *argp2;
10275   {
10276     try {
10277       result = (bool)Dali::operator ==(arg1,arg2);
10278     } catch (std::out_of_range& e) {
10279       {
10280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10281       };
10282     } catch (std::exception& e) {
10283       {
10284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10285       };
10286     } catch (Dali::DaliException e) {
10287       {
10288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10289       };
10290     } catch (...) {
10291       {
10292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10293       };
10294     }
10295   }
10296
10297   jresult = result;
10298   return jresult;
10299 }
10300
10301
10302 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
10303   unsigned int jresult ;
10304   Dali::Degree arg1 ;
10305   Dali::Radian arg2 ;
10306   Dali::Degree *argp1 ;
10307   Dali::Radian *argp2 ;
10308   bool result;
10309
10310   argp1 = (Dali::Degree *)jarg1;
10311   if (!argp1) {
10312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10313     return 0;
10314   }
10315   arg1 = *argp1;
10316   argp2 = (Dali::Radian *)jarg2;
10317   if (!argp2) {
10318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10319     return 0;
10320   }
10321   arg2 = *argp2;
10322   {
10323     try {
10324       result = (bool)Dali::operator !=(arg1,arg2);
10325     } catch (std::out_of_range& e) {
10326       {
10327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10328       };
10329     } catch (std::exception& e) {
10330       {
10331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10332       };
10333     } catch (Dali::DaliException e) {
10334       {
10335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10336       };
10337     } catch (...) {
10338       {
10339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10340       };
10341     }
10342   }
10343
10344   jresult = result;
10345   return jresult;
10346 }
10347
10348
10349 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
10350   unsigned int jresult ;
10351   Dali::Radian arg1 ;
10352   Dali::Radian arg2 ;
10353   Dali::Radian *argp1 ;
10354   Dali::Radian *argp2 ;
10355   bool result;
10356
10357   argp1 = (Dali::Radian *)jarg1;
10358   if (!argp1) {
10359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10360     return 0;
10361   }
10362   arg1 = *argp1;
10363   argp2 = (Dali::Radian *)jarg2;
10364   if (!argp2) {
10365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10366     return 0;
10367   }
10368   arg2 = *argp2;
10369   {
10370     try {
10371       result = (bool)Dali::operator >(arg1,arg2);
10372     } catch (std::out_of_range& e) {
10373       {
10374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10375       };
10376     } catch (std::exception& e) {
10377       {
10378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10379       };
10380     } catch (Dali::DaliException e) {
10381       {
10382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10383       };
10384     } catch (...) {
10385       {
10386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10387       };
10388     }
10389   }
10390
10391   jresult = result;
10392   return jresult;
10393 }
10394
10395
10396 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
10397   unsigned int jresult ;
10398   Dali::Radian arg1 ;
10399   Dali::Degree arg2 ;
10400   Dali::Radian *argp1 ;
10401   Dali::Degree *argp2 ;
10402   bool result;
10403
10404   argp1 = (Dali::Radian *)jarg1;
10405   if (!argp1) {
10406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10407     return 0;
10408   }
10409   arg1 = *argp1;
10410   argp2 = (Dali::Degree *)jarg2;
10411   if (!argp2) {
10412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10413     return 0;
10414   }
10415   arg2 = *argp2;
10416   {
10417     try {
10418       result = (bool)Dali::operator >(arg1,arg2);
10419     } catch (std::out_of_range& e) {
10420       {
10421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10422       };
10423     } catch (std::exception& e) {
10424       {
10425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10426       };
10427     } catch (Dali::DaliException e) {
10428       {
10429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10430       };
10431     } catch (...) {
10432       {
10433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10434       };
10435     }
10436   }
10437
10438   jresult = result;
10439   return jresult;
10440 }
10441
10442
10443 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
10444   unsigned int jresult ;
10445   Dali::Degree arg1 ;
10446   Dali::Radian arg2 ;
10447   Dali::Degree *argp1 ;
10448   Dali::Radian *argp2 ;
10449   bool result;
10450
10451   argp1 = (Dali::Degree *)jarg1;
10452   if (!argp1) {
10453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10454     return 0;
10455   }
10456   arg1 = *argp1;
10457   argp2 = (Dali::Radian *)jarg2;
10458   if (!argp2) {
10459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10460     return 0;
10461   }
10462   arg2 = *argp2;
10463   {
10464     try {
10465       result = (bool)Dali::operator >(arg1,arg2);
10466     } catch (std::out_of_range& e) {
10467       {
10468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10469       };
10470     } catch (std::exception& e) {
10471       {
10472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10473       };
10474     } catch (Dali::DaliException e) {
10475       {
10476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10477       };
10478     } catch (...) {
10479       {
10480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10481       };
10482     }
10483   }
10484
10485   jresult = result;
10486   return jresult;
10487 }
10488
10489
10490 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
10491   unsigned int jresult ;
10492   Dali::Radian arg1 ;
10493   Dali::Radian arg2 ;
10494   Dali::Radian *argp1 ;
10495   Dali::Radian *argp2 ;
10496   bool result;
10497
10498   argp1 = (Dali::Radian *)jarg1;
10499   if (!argp1) {
10500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10501     return 0;
10502   }
10503   arg1 = *argp1;
10504   argp2 = (Dali::Radian *)jarg2;
10505   if (!argp2) {
10506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10507     return 0;
10508   }
10509   arg2 = *argp2;
10510   {
10511     try {
10512       result = (bool)Dali::operator <(arg1,arg2);
10513     } catch (std::out_of_range& e) {
10514       {
10515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10516       };
10517     } catch (std::exception& e) {
10518       {
10519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10520       };
10521     } catch (Dali::DaliException e) {
10522       {
10523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10524       };
10525     } catch (...) {
10526       {
10527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10528       };
10529     }
10530   }
10531
10532   jresult = result;
10533   return jresult;
10534 }
10535
10536
10537 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
10538   unsigned int jresult ;
10539   Dali::Radian arg1 ;
10540   Dali::Degree arg2 ;
10541   Dali::Radian *argp1 ;
10542   Dali::Degree *argp2 ;
10543   bool result;
10544
10545   argp1 = (Dali::Radian *)jarg1;
10546   if (!argp1) {
10547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10548     return 0;
10549   }
10550   arg1 = *argp1;
10551   argp2 = (Dali::Degree *)jarg2;
10552   if (!argp2) {
10553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10554     return 0;
10555   }
10556   arg2 = *argp2;
10557   {
10558     try {
10559       result = (bool)Dali::operator <(arg1,arg2);
10560     } catch (std::out_of_range& e) {
10561       {
10562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10563       };
10564     } catch (std::exception& e) {
10565       {
10566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10567       };
10568     } catch (Dali::DaliException e) {
10569       {
10570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10571       };
10572     } catch (...) {
10573       {
10574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10575       };
10576     }
10577   }
10578
10579   jresult = result;
10580   return jresult;
10581 }
10582
10583
10584 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
10585   unsigned int jresult ;
10586   Dali::Degree arg1 ;
10587   Dali::Radian arg2 ;
10588   Dali::Degree *argp1 ;
10589   Dali::Radian *argp2 ;
10590   bool result;
10591
10592   argp1 = (Dali::Degree *)jarg1;
10593   if (!argp1) {
10594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10595     return 0;
10596   }
10597   arg1 = *argp1;
10598   argp2 = (Dali::Radian *)jarg2;
10599   if (!argp2) {
10600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10601     return 0;
10602   }
10603   arg2 = *argp2;
10604   {
10605     try {
10606       result = (bool)Dali::operator <(arg1,arg2);
10607     } catch (std::out_of_range& e) {
10608       {
10609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10610       };
10611     } catch (std::exception& e) {
10612       {
10613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10614       };
10615     } catch (Dali::DaliException e) {
10616       {
10617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10618       };
10619     } catch (...) {
10620       {
10621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10622       };
10623     }
10624   }
10625
10626   jresult = result;
10627   return jresult;
10628 }
10629
10630
10631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
10632   void * jresult ;
10633   Dali::Radian arg1 ;
10634   float arg2 ;
10635   Dali::Radian *argp1 ;
10636   Dali::Radian result;
10637
10638   argp1 = (Dali::Radian *)jarg1;
10639   if (!argp1) {
10640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10641     return 0;
10642   }
10643   arg1 = *argp1;
10644   arg2 = (float)jarg2;
10645   {
10646     try {
10647       result = Dali::operator *(arg1,arg2);
10648     } catch (std::out_of_range& e) {
10649       {
10650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10651       };
10652     } catch (std::exception& e) {
10653       {
10654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10655       };
10656     } catch (Dali::DaliException e) {
10657       {
10658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10659       };
10660     } catch (...) {
10661       {
10662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10663       };
10664     }
10665   }
10666
10667   jresult = new Dali::Radian((const Dali::Radian &)result);
10668   return jresult;
10669 }
10670
10671
10672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
10673   void * jresult ;
10674   Dali::Radian arg1 ;
10675   Dali::Radian *argp1 ;
10676   Dali::Radian result;
10677
10678   argp1 = (Dali::Radian *)jarg1;
10679   if (!argp1) {
10680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10681     return 0;
10682   }
10683   arg1 = *argp1;
10684   {
10685     try {
10686       result = Dali::operator -(arg1);
10687     } catch (std::out_of_range& e) {
10688       {
10689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10690       };
10691     } catch (std::exception& e) {
10692       {
10693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10694       };
10695     } catch (Dali::DaliException e) {
10696       {
10697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10698       };
10699     } catch (...) {
10700       {
10701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10702       };
10703     }
10704   }
10705
10706   jresult = new Dali::Radian((const Dali::Radian &)result);
10707   return jresult;
10708 }
10709
10710
10711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
10712   void * jresult ;
10713   Dali::Radian arg1 ;
10714   float arg2 ;
10715   float arg3 ;
10716   Dali::Radian *argp1 ;
10717   Dali::Radian result;
10718
10719   argp1 = (Dali::Radian *)jarg1;
10720   if (!argp1) {
10721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10722     return 0;
10723   }
10724   arg1 = *argp1;
10725   arg2 = (float)jarg2;
10726   arg3 = (float)jarg3;
10727   {
10728     try {
10729       result = Dali::Clamp(arg1,arg2,arg3);
10730     } catch (std::out_of_range& e) {
10731       {
10732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10733       };
10734     } catch (std::exception& e) {
10735       {
10736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10737       };
10738     } catch (Dali::DaliException e) {
10739       {
10740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10741       };
10742     } catch (...) {
10743       {
10744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10745       };
10746     }
10747   }
10748
10749   jresult = new Dali::Radian((const Dali::Radian &)result);
10750   return jresult;
10751 }
10752
10753
10754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
10755   void * jresult ;
10756   Dali::Quaternion *result = 0 ;
10757
10758   {
10759     try {
10760       result = (Dali::Quaternion *)new Dali::Quaternion();
10761     } catch (std::out_of_range& e) {
10762       {
10763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10764       };
10765     } catch (std::exception& e) {
10766       {
10767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10768       };
10769     } catch (Dali::DaliException e) {
10770       {
10771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10772       };
10773     } catch (...) {
10774       {
10775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10776       };
10777     }
10778   }
10779
10780   jresult = (void *)result;
10781   return jresult;
10782 }
10783
10784
10785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
10786   void * jresult ;
10787   Dali::Radian arg1 ;
10788   Dali::Vector3 *arg2 = 0 ;
10789   Dali::Radian *argp1 ;
10790   Dali::Quaternion *result = 0 ;
10791
10792   argp1 = (Dali::Radian *)jarg1;
10793   if (!argp1) {
10794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10795     return 0;
10796   }
10797   arg1 = *argp1;
10798   arg2 = (Dali::Vector3 *)jarg2;
10799   if (!arg2) {
10800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10801     return 0;
10802   }
10803   {
10804     try {
10805       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
10806     } catch (std::out_of_range& e) {
10807       {
10808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10809       };
10810     } catch (std::exception& e) {
10811       {
10812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10813       };
10814     } catch (Dali::DaliException e) {
10815       {
10816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10817       };
10818     } catch (...) {
10819       {
10820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10821       };
10822     }
10823   }
10824
10825   jresult = (void *)result;
10826   return jresult;
10827 }
10828
10829
10830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
10831   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10832
10833   arg1 = (Dali::Quaternion *)jarg1;
10834   {
10835     try {
10836       delete arg1;
10837     } catch (std::out_of_range& e) {
10838       {
10839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10840       };
10841     } catch (std::exception& e) {
10842       {
10843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10844       };
10845     } catch (Dali::DaliException e) {
10846       {
10847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10848       };
10849     } catch (...) {
10850       {
10851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10852       };
10853     }
10854   }
10855
10856 }
10857
10858
10859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
10860   void * jresult ;
10861   Dali::Quaternion *result = 0 ;
10862
10863   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
10864   jresult = (void *)result;
10865   return jresult;
10866 }
10867
10868
10869 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
10870   unsigned int jresult ;
10871   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10872   bool result;
10873
10874   arg1 = (Dali::Quaternion *)jarg1;
10875   {
10876     try {
10877       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
10878     } catch (std::out_of_range& e) {
10879       {
10880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10881       };
10882     } catch (std::exception& e) {
10883       {
10884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10885       };
10886     } catch (Dali::DaliException e) {
10887       {
10888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10889       };
10890     } catch (...) {
10891       {
10892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10893       };
10894     }
10895   }
10896
10897   jresult = result;
10898   return jresult;
10899 }
10900
10901
10902 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
10903   unsigned int jresult ;
10904   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10905   Dali::Vector3 *arg2 = 0 ;
10906   Dali::Radian *arg3 = 0 ;
10907   bool result;
10908
10909   arg1 = (Dali::Quaternion *)jarg1;
10910   arg2 = (Dali::Vector3 *)jarg2;
10911   if (!arg2) {
10912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
10913     return 0;
10914   }
10915   arg3 = (Dali::Radian *)jarg3;
10916   if (!arg3) {
10917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
10918     return 0;
10919   }
10920   {
10921     try {
10922       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
10923     } catch (std::out_of_range& e) {
10924       {
10925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10926       };
10927     } catch (std::exception& e) {
10928       {
10929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10930       };
10931     } catch (Dali::DaliException e) {
10932       {
10933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10934       };
10935     } catch (...) {
10936       {
10937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10938       };
10939     }
10940   }
10941
10942   jresult = result;
10943   return jresult;
10944 }
10945
10946
10947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
10948   void * jresult ;
10949   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10950   Dali::Quaternion *arg2 = 0 ;
10951   Dali::Quaternion result;
10952
10953   arg1 = (Dali::Quaternion *)jarg1;
10954   arg2 = (Dali::Quaternion *)jarg2;
10955   if (!arg2) {
10956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10957     return 0;
10958   }
10959   {
10960     try {
10961       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
10962     } catch (std::out_of_range& e) {
10963       {
10964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10965       };
10966     } catch (std::exception& e) {
10967       {
10968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10969       };
10970     } catch (Dali::DaliException e) {
10971       {
10972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10973       };
10974     } catch (...) {
10975       {
10976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10977       };
10978     }
10979   }
10980
10981   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10982   return jresult;
10983 }
10984
10985
10986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
10987   void * jresult ;
10988   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10989   Dali::Quaternion *arg2 = 0 ;
10990   Dali::Quaternion result;
10991
10992   arg1 = (Dali::Quaternion *)jarg1;
10993   arg2 = (Dali::Quaternion *)jarg2;
10994   if (!arg2) {
10995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10996     return 0;
10997   }
10998   {
10999     try {
11000       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
11001     } catch (std::out_of_range& e) {
11002       {
11003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11004       };
11005     } catch (std::exception& e) {
11006       {
11007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11008       };
11009     } catch (Dali::DaliException e) {
11010       {
11011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11012       };
11013     } catch (...) {
11014       {
11015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11016       };
11017     }
11018   }
11019
11020   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11021   return jresult;
11022 }
11023
11024
11025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
11026   void * jresult ;
11027   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11028   Dali::Quaternion *arg2 = 0 ;
11029   Dali::Quaternion result;
11030
11031   arg1 = (Dali::Quaternion *)jarg1;
11032   arg2 = (Dali::Quaternion *)jarg2;
11033   if (!arg2) {
11034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11035     return 0;
11036   }
11037   {
11038     try {
11039       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
11040     } catch (std::out_of_range& e) {
11041       {
11042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11043       };
11044     } catch (std::exception& e) {
11045       {
11046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11047       };
11048     } catch (Dali::DaliException e) {
11049       {
11050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11051       };
11052     } catch (...) {
11053       {
11054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11055       };
11056     }
11057   }
11058
11059   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11060   return jresult;
11061 }
11062
11063
11064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
11065   void * jresult ;
11066   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11067   Dali::Vector3 *arg2 = 0 ;
11068   Dali::Vector3 result;
11069
11070   arg1 = (Dali::Quaternion *)jarg1;
11071   arg2 = (Dali::Vector3 *)jarg2;
11072   if (!arg2) {
11073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11074     return 0;
11075   }
11076   {
11077     try {
11078       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
11079     } catch (std::out_of_range& e) {
11080       {
11081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11082       };
11083     } catch (std::exception& e) {
11084       {
11085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11086       };
11087     } catch (Dali::DaliException e) {
11088       {
11089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11090       };
11091     } catch (...) {
11092       {
11093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11094       };
11095     }
11096   }
11097
11098   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11099   return jresult;
11100 }
11101
11102
11103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
11104   void * jresult ;
11105   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11106   Dali::Quaternion *arg2 = 0 ;
11107   Dali::Quaternion result;
11108
11109   arg1 = (Dali::Quaternion *)jarg1;
11110   arg2 = (Dali::Quaternion *)jarg2;
11111   if (!arg2) {
11112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11113     return 0;
11114   }
11115   {
11116     try {
11117       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
11118     } catch (std::out_of_range& e) {
11119       {
11120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11121       };
11122     } catch (std::exception& e) {
11123       {
11124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11125       };
11126     } catch (Dali::DaliException e) {
11127       {
11128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11129       };
11130     } catch (...) {
11131       {
11132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11133       };
11134     }
11135   }
11136
11137   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11138   return jresult;
11139 }
11140
11141
11142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
11143   void * jresult ;
11144   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11145   float arg2 ;
11146   Dali::Quaternion result;
11147
11148   arg1 = (Dali::Quaternion *)jarg1;
11149   arg2 = (float)jarg2;
11150   {
11151     try {
11152       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
11153     } catch (std::out_of_range& e) {
11154       {
11155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11156       };
11157     } catch (std::exception& e) {
11158       {
11159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11160       };
11161     } catch (Dali::DaliException e) {
11162       {
11163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11164       };
11165     } catch (...) {
11166       {
11167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11168       };
11169     }
11170   }
11171
11172   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11173   return jresult;
11174 }
11175
11176
11177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
11178   void * jresult ;
11179   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11180   float arg2 ;
11181   Dali::Quaternion result;
11182
11183   arg1 = (Dali::Quaternion *)jarg1;
11184   arg2 = (float)jarg2;
11185   {
11186     try {
11187       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
11188     } catch (std::out_of_range& e) {
11189       {
11190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11191       };
11192     } catch (std::exception& e) {
11193       {
11194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11195       };
11196     } catch (Dali::DaliException e) {
11197       {
11198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11199       };
11200     } catch (...) {
11201       {
11202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11203       };
11204     }
11205   }
11206
11207   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11208   return jresult;
11209 }
11210
11211
11212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
11213   void * jresult ;
11214   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11215   Dali::Quaternion result;
11216
11217   arg1 = (Dali::Quaternion *)jarg1;
11218   {
11219     try {
11220       result = ((Dali::Quaternion const *)arg1)->operator -();
11221     } catch (std::out_of_range& e) {
11222       {
11223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11224       };
11225     } catch (std::exception& e) {
11226       {
11227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11228       };
11229     } catch (Dali::DaliException e) {
11230       {
11231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11232       };
11233     } catch (...) {
11234       {
11235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11236       };
11237     }
11238   }
11239
11240   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11241   return jresult;
11242 }
11243
11244
11245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
11246   void * jresult ;
11247   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11248   Dali::Quaternion *arg2 = 0 ;
11249   Dali::Quaternion *result = 0 ;
11250
11251   arg1 = (Dali::Quaternion *)jarg1;
11252   arg2 = (Dali::Quaternion *)jarg2;
11253   if (!arg2) {
11254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11255     return 0;
11256   }
11257   {
11258     try {
11259       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
11260     } catch (std::out_of_range& e) {
11261       {
11262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11263       };
11264     } catch (std::exception& e) {
11265       {
11266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11267       };
11268     } catch (Dali::DaliException e) {
11269       {
11270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11271       };
11272     } catch (...) {
11273       {
11274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11275       };
11276     }
11277   }
11278
11279   jresult = (void *)result;
11280   return jresult;
11281 }
11282
11283
11284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
11285   void * jresult ;
11286   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11287   Dali::Quaternion *arg2 = 0 ;
11288   Dali::Quaternion *result = 0 ;
11289
11290   arg1 = (Dali::Quaternion *)jarg1;
11291   arg2 = (Dali::Quaternion *)jarg2;
11292   if (!arg2) {
11293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11294     return 0;
11295   }
11296   {
11297     try {
11298       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
11299     } catch (std::out_of_range& e) {
11300       {
11301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11302       };
11303     } catch (std::exception& e) {
11304       {
11305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11306       };
11307     } catch (Dali::DaliException e) {
11308       {
11309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11310       };
11311     } catch (...) {
11312       {
11313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11314       };
11315     }
11316   }
11317
11318   jresult = (void *)result;
11319   return jresult;
11320 }
11321
11322
11323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
11324   void * jresult ;
11325   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11326   Dali::Quaternion *arg2 = 0 ;
11327   Dali::Quaternion *result = 0 ;
11328
11329   arg1 = (Dali::Quaternion *)jarg1;
11330   arg2 = (Dali::Quaternion *)jarg2;
11331   if (!arg2) {
11332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11333     return 0;
11334   }
11335   {
11336     try {
11337       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
11338     } catch (std::out_of_range& e) {
11339       {
11340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11341       };
11342     } catch (std::exception& e) {
11343       {
11344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11345       };
11346     } catch (Dali::DaliException e) {
11347       {
11348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11349       };
11350     } catch (...) {
11351       {
11352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11353       };
11354     }
11355   }
11356
11357   jresult = (void *)result;
11358   return jresult;
11359 }
11360
11361
11362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
11363   void * jresult ;
11364   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11365   float arg2 ;
11366   Dali::Quaternion *result = 0 ;
11367
11368   arg1 = (Dali::Quaternion *)jarg1;
11369   arg2 = (float)jarg2;
11370   {
11371     try {
11372       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
11373     } catch (std::out_of_range& e) {
11374       {
11375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11376       };
11377     } catch (std::exception& e) {
11378       {
11379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11380       };
11381     } catch (Dali::DaliException e) {
11382       {
11383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11384       };
11385     } catch (...) {
11386       {
11387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11388       };
11389     }
11390   }
11391
11392   jresult = (void *)result;
11393   return jresult;
11394 }
11395
11396
11397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
11398   void * jresult ;
11399   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11400   float arg2 ;
11401   Dali::Quaternion *result = 0 ;
11402
11403   arg1 = (Dali::Quaternion *)jarg1;
11404   arg2 = (float)jarg2;
11405   {
11406     try {
11407       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
11408     } catch (std::out_of_range& e) {
11409       {
11410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11411       };
11412     } catch (std::exception& e) {
11413       {
11414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11415       };
11416     } catch (Dali::DaliException e) {
11417       {
11418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11419       };
11420     } catch (...) {
11421       {
11422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11423       };
11424     }
11425   }
11426
11427   jresult = (void *)result;
11428   return jresult;
11429 }
11430
11431
11432 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
11433   unsigned int jresult ;
11434   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11435   Dali::Quaternion *arg2 = 0 ;
11436   bool result;
11437
11438   arg1 = (Dali::Quaternion *)jarg1;
11439   arg2 = (Dali::Quaternion *)jarg2;
11440   if (!arg2) {
11441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11442     return 0;
11443   }
11444   {
11445     try {
11446       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
11447     } catch (std::out_of_range& e) {
11448       {
11449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11450       };
11451     } catch (std::exception& e) {
11452       {
11453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11454       };
11455     } catch (Dali::DaliException e) {
11456       {
11457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11458       };
11459     } catch (...) {
11460       {
11461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11462       };
11463     }
11464   }
11465
11466   jresult = result;
11467   return jresult;
11468 }
11469
11470
11471 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
11472   unsigned int jresult ;
11473   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11474   Dali::Quaternion *arg2 = 0 ;
11475   bool result;
11476
11477   arg1 = (Dali::Quaternion *)jarg1;
11478   arg2 = (Dali::Quaternion *)jarg2;
11479   if (!arg2) {
11480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11481     return 0;
11482   }
11483   {
11484     try {
11485       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
11486     } catch (std::out_of_range& e) {
11487       {
11488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11489       };
11490     } catch (std::exception& e) {
11491       {
11492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11493       };
11494     } catch (Dali::DaliException e) {
11495       {
11496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11497       };
11498     } catch (...) {
11499       {
11500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11501       };
11502     }
11503   }
11504
11505   jresult = result;
11506   return jresult;
11507 }
11508
11509
11510 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
11511   float jresult ;
11512   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11513   float result;
11514
11515   arg1 = (Dali::Quaternion *)jarg1;
11516   {
11517     try {
11518       result = (float)((Dali::Quaternion const *)arg1)->Length();
11519     } catch (std::out_of_range& e) {
11520       {
11521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11522       };
11523     } catch (std::exception& e) {
11524       {
11525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11526       };
11527     } catch (Dali::DaliException e) {
11528       {
11529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11530       };
11531     } catch (...) {
11532       {
11533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11534       };
11535     }
11536   }
11537
11538   jresult = result;
11539   return jresult;
11540 }
11541
11542
11543 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
11544   float jresult ;
11545   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11546   float result;
11547
11548   arg1 = (Dali::Quaternion *)jarg1;
11549   {
11550     try {
11551       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
11552     } catch (std::out_of_range& e) {
11553       {
11554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11555       };
11556     } catch (std::exception& e) {
11557       {
11558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11559       };
11560     } catch (Dali::DaliException e) {
11561       {
11562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11563       };
11564     } catch (...) {
11565       {
11566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11567       };
11568     }
11569   }
11570
11571   jresult = result;
11572   return jresult;
11573 }
11574
11575
11576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
11577   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11578
11579   arg1 = (Dali::Quaternion *)jarg1;
11580   {
11581     try {
11582       (arg1)->Normalize();
11583     } catch (std::out_of_range& e) {
11584       {
11585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11586       };
11587     } catch (std::exception& e) {
11588       {
11589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11590       };
11591     } catch (Dali::DaliException e) {
11592       {
11593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11594       };
11595     } catch (...) {
11596       {
11597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11598       };
11599     }
11600   }
11601
11602 }
11603
11604
11605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
11606   void * jresult ;
11607   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11608   Dali::Quaternion result;
11609
11610   arg1 = (Dali::Quaternion *)jarg1;
11611   {
11612     try {
11613       result = ((Dali::Quaternion const *)arg1)->Normalized();
11614     } catch (std::out_of_range& e) {
11615       {
11616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11617       };
11618     } catch (std::exception& e) {
11619       {
11620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11621       };
11622     } catch (Dali::DaliException e) {
11623       {
11624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11625       };
11626     } catch (...) {
11627       {
11628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11629       };
11630     }
11631   }
11632
11633   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11634   return jresult;
11635 }
11636
11637
11638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
11639   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11640
11641   arg1 = (Dali::Quaternion *)jarg1;
11642   {
11643     try {
11644       (arg1)->Conjugate();
11645     } catch (std::out_of_range& e) {
11646       {
11647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11648       };
11649     } catch (std::exception& e) {
11650       {
11651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11652       };
11653     } catch (Dali::DaliException e) {
11654       {
11655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11656       };
11657     } catch (...) {
11658       {
11659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11660       };
11661     }
11662   }
11663
11664 }
11665
11666
11667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
11668   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11669
11670   arg1 = (Dali::Quaternion *)jarg1;
11671   {
11672     try {
11673       (arg1)->Invert();
11674     } catch (std::out_of_range& e) {
11675       {
11676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11677       };
11678     } catch (std::exception& e) {
11679       {
11680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11681       };
11682     } catch (Dali::DaliException e) {
11683       {
11684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11685       };
11686     } catch (...) {
11687       {
11688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11689       };
11690     }
11691   }
11692
11693 }
11694
11695
11696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
11697   void * jresult ;
11698   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11699   Dali::Quaternion result;
11700
11701   arg1 = (Dali::Quaternion *)jarg1;
11702   {
11703     try {
11704       result = ((Dali::Quaternion const *)arg1)->Log();
11705     } catch (std::out_of_range& e) {
11706       {
11707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11708       };
11709     } catch (std::exception& e) {
11710       {
11711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11712       };
11713     } catch (Dali::DaliException e) {
11714       {
11715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11716       };
11717     } catch (...) {
11718       {
11719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11720       };
11721     }
11722   }
11723
11724   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11725   return jresult;
11726 }
11727
11728
11729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
11730   void * jresult ;
11731   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11732   Dali::Quaternion result;
11733
11734   arg1 = (Dali::Quaternion *)jarg1;
11735   {
11736     try {
11737       result = ((Dali::Quaternion const *)arg1)->Exp();
11738     } catch (std::out_of_range& e) {
11739       {
11740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11741       };
11742     } catch (std::exception& e) {
11743       {
11744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11745       };
11746     } catch (Dali::DaliException e) {
11747       {
11748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11749       };
11750     } catch (...) {
11751       {
11752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11753       };
11754     }
11755   }
11756
11757   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11758   return jresult;
11759 }
11760
11761
11762 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
11763   float jresult ;
11764   Dali::Quaternion *arg1 = 0 ;
11765   Dali::Quaternion *arg2 = 0 ;
11766   float result;
11767
11768   arg1 = (Dali::Quaternion *)jarg1;
11769   if (!arg1) {
11770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11771     return 0;
11772   }
11773   arg2 = (Dali::Quaternion *)jarg2;
11774   if (!arg2) {
11775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11776     return 0;
11777   }
11778   {
11779     try {
11780       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
11781     } catch (std::out_of_range& e) {
11782       {
11783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11784       };
11785     } catch (std::exception& e) {
11786       {
11787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11788       };
11789     } catch (Dali::DaliException e) {
11790       {
11791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11792       };
11793     } catch (...) {
11794       {
11795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11796       };
11797     }
11798   }
11799
11800   jresult = result;
11801   return jresult;
11802 }
11803
11804
11805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
11806   void * jresult ;
11807   Dali::Quaternion *arg1 = 0 ;
11808   Dali::Quaternion *arg2 = 0 ;
11809   float arg3 ;
11810   Dali::Quaternion result;
11811
11812   arg1 = (Dali::Quaternion *)jarg1;
11813   if (!arg1) {
11814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11815     return 0;
11816   }
11817   arg2 = (Dali::Quaternion *)jarg2;
11818   if (!arg2) {
11819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11820     return 0;
11821   }
11822   arg3 = (float)jarg3;
11823   {
11824     try {
11825       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11826     } catch (std::out_of_range& e) {
11827       {
11828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11829       };
11830     } catch (std::exception& e) {
11831       {
11832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11833       };
11834     } catch (Dali::DaliException e) {
11835       {
11836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11837       };
11838     } catch (...) {
11839       {
11840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11841       };
11842     }
11843   }
11844
11845   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11846   return jresult;
11847 }
11848
11849
11850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
11851   void * jresult ;
11852   Dali::Quaternion *arg1 = 0 ;
11853   Dali::Quaternion *arg2 = 0 ;
11854   float arg3 ;
11855   Dali::Quaternion result;
11856
11857   arg1 = (Dali::Quaternion *)jarg1;
11858   if (!arg1) {
11859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11860     return 0;
11861   }
11862   arg2 = (Dali::Quaternion *)jarg2;
11863   if (!arg2) {
11864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11865     return 0;
11866   }
11867   arg3 = (float)jarg3;
11868   {
11869     try {
11870       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11871     } catch (std::out_of_range& e) {
11872       {
11873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11874       };
11875     } catch (std::exception& e) {
11876       {
11877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11878       };
11879     } catch (Dali::DaliException e) {
11880       {
11881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11882       };
11883     } catch (...) {
11884       {
11885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11886       };
11887     }
11888   }
11889
11890   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11891   return jresult;
11892 }
11893
11894
11895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
11896   void * jresult ;
11897   Dali::Quaternion *arg1 = 0 ;
11898   Dali::Quaternion *arg2 = 0 ;
11899   float arg3 ;
11900   Dali::Quaternion result;
11901
11902   arg1 = (Dali::Quaternion *)jarg1;
11903   if (!arg1) {
11904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11905     return 0;
11906   }
11907   arg2 = (Dali::Quaternion *)jarg2;
11908   if (!arg2) {
11909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11910     return 0;
11911   }
11912   arg3 = (float)jarg3;
11913   {
11914     try {
11915       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11916     } catch (std::out_of_range& e) {
11917       {
11918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11919       };
11920     } catch (std::exception& e) {
11921       {
11922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11923       };
11924     } catch (Dali::DaliException e) {
11925       {
11926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11927       };
11928     } catch (...) {
11929       {
11930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11931       };
11932     }
11933   }
11934
11935   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11936   return jresult;
11937 }
11938
11939
11940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
11941   void * jresult ;
11942   Dali::Quaternion *arg1 = 0 ;
11943   Dali::Quaternion *arg2 = 0 ;
11944   Dali::Quaternion *arg3 = 0 ;
11945   Dali::Quaternion *arg4 = 0 ;
11946   float arg5 ;
11947   Dali::Quaternion result;
11948
11949   arg1 = (Dali::Quaternion *)jarg1;
11950   if (!arg1) {
11951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11952     return 0;
11953   }
11954   arg2 = (Dali::Quaternion *)jarg2;
11955   if (!arg2) {
11956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11957     return 0;
11958   }
11959   arg3 = (Dali::Quaternion *)jarg3;
11960   if (!arg3) {
11961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11962     return 0;
11963   }
11964   arg4 = (Dali::Quaternion *)jarg4;
11965   if (!arg4) {
11966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11967     return 0;
11968   }
11969   arg5 = (float)jarg5;
11970   {
11971     try {
11972       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
11973     } catch (std::out_of_range& e) {
11974       {
11975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11976       };
11977     } catch (std::exception& e) {
11978       {
11979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11980       };
11981     } catch (Dali::DaliException e) {
11982       {
11983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11984       };
11985     } catch (...) {
11986       {
11987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11988       };
11989     }
11990   }
11991
11992   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11993   return jresult;
11994 }
11995
11996
11997 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
11998   float jresult ;
11999   Dali::Quaternion *arg1 = 0 ;
12000   Dali::Quaternion *arg2 = 0 ;
12001   float result;
12002
12003   arg1 = (Dali::Quaternion *)jarg1;
12004   if (!arg1) {
12005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12006     return 0;
12007   }
12008   arg2 = (Dali::Quaternion *)jarg2;
12009   if (!arg2) {
12010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12011     return 0;
12012   }
12013   {
12014     try {
12015       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
12016     } catch (std::out_of_range& e) {
12017       {
12018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12019       };
12020     } catch (std::exception& e) {
12021       {
12022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12023       };
12024     } catch (Dali::DaliException e) {
12025       {
12026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12027       };
12028     } catch (...) {
12029       {
12030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12031       };
12032     }
12033   }
12034
12035   jresult = result;
12036   return jresult;
12037 }
12038
12039
12040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
12041   void * jresult ;
12042   Dali::Matrix *result = 0 ;
12043
12044   {
12045     try {
12046       result = (Dali::Matrix *)new Dali::Matrix();
12047     } catch (std::out_of_range& e) {
12048       {
12049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12050       };
12051     } catch (std::exception& e) {
12052       {
12053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12054       };
12055     } catch (Dali::DaliException e) {
12056       {
12057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12058       };
12059     } catch (...) {
12060       {
12061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12062       };
12063     }
12064   }
12065
12066   jresult = (void *)result;
12067   return jresult;
12068 }
12069
12070
12071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
12072   void * jresult ;
12073   bool arg1 ;
12074   Dali::Matrix *result = 0 ;
12075
12076   arg1 = jarg1 ? true : false;
12077   {
12078     try {
12079       result = (Dali::Matrix *)new Dali::Matrix(arg1);
12080     } catch (std::out_of_range& e) {
12081       {
12082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12083       };
12084     } catch (std::exception& e) {
12085       {
12086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12087       };
12088     } catch (Dali::DaliException e) {
12089       {
12090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12091       };
12092     } catch (...) {
12093       {
12094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12095       };
12096     }
12097   }
12098
12099   jresult = (void *)result;
12100   return jresult;
12101 }
12102
12103
12104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
12105   void * jresult ;
12106   float *arg1 = (float *) 0 ;
12107   Dali::Matrix *result = 0 ;
12108
12109   arg1 = jarg1;
12110   {
12111     try {
12112       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
12113     } catch (std::out_of_range& e) {
12114       {
12115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12116       };
12117     } catch (std::exception& e) {
12118       {
12119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12120       };
12121     } catch (Dali::DaliException e) {
12122       {
12123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12124       };
12125     } catch (...) {
12126       {
12127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12128       };
12129     }
12130   }
12131
12132   jresult = (void *)result;
12133
12134
12135   return jresult;
12136 }
12137
12138
12139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
12140   void * jresult ;
12141   Dali::Quaternion *arg1 = 0 ;
12142   Dali::Matrix *result = 0 ;
12143
12144   arg1 = (Dali::Quaternion *)jarg1;
12145   if (!arg1) {
12146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12147     return 0;
12148   }
12149   {
12150     try {
12151       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
12152     } catch (std::out_of_range& e) {
12153       {
12154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12155       };
12156     } catch (std::exception& e) {
12157       {
12158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12159       };
12160     } catch (Dali::DaliException e) {
12161       {
12162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12163       };
12164     } catch (...) {
12165       {
12166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12167       };
12168     }
12169   }
12170
12171   jresult = (void *)result;
12172   return jresult;
12173 }
12174
12175
12176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
12177   void * jresult ;
12178   Dali::Matrix *arg1 = 0 ;
12179   Dali::Matrix *result = 0 ;
12180
12181   arg1 = (Dali::Matrix *)jarg1;
12182   if (!arg1) {
12183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12184     return 0;
12185   }
12186   {
12187     try {
12188       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
12189     } catch (std::out_of_range& e) {
12190       {
12191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12192       };
12193     } catch (std::exception& e) {
12194       {
12195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12196       };
12197     } catch (Dali::DaliException e) {
12198       {
12199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12200       };
12201     } catch (...) {
12202       {
12203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12204       };
12205     }
12206   }
12207
12208   jresult = (void *)result;
12209   return jresult;
12210 }
12211
12212
12213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
12214   void * jresult ;
12215   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12216   Dali::Matrix *arg2 = 0 ;
12217   Dali::Matrix *result = 0 ;
12218
12219   arg1 = (Dali::Matrix *)jarg1;
12220   arg2 = (Dali::Matrix *)jarg2;
12221   if (!arg2) {
12222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12223     return 0;
12224   }
12225   {
12226     try {
12227       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12228     } catch (std::out_of_range& e) {
12229       {
12230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12231       };
12232     } catch (std::exception& e) {
12233       {
12234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12235       };
12236     } catch (Dali::DaliException e) {
12237       {
12238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12239       };
12240     } catch (...) {
12241       {
12242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12243       };
12244     }
12245   }
12246
12247   jresult = (void *)result;
12248   return jresult;
12249 }
12250
12251
12252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
12253   void * jresult ;
12254   Dali::Matrix *result = 0 ;
12255
12256   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
12257   jresult = (void *)result;
12258   return jresult;
12259 }
12260
12261
12262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
12263   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12264
12265   arg1 = (Dali::Matrix *)jarg1;
12266   {
12267     try {
12268       (arg1)->SetIdentity();
12269     } catch (std::out_of_range& e) {
12270       {
12271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12272       };
12273     } catch (std::exception& e) {
12274       {
12275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12276       };
12277     } catch (Dali::DaliException e) {
12278       {
12279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12280       };
12281     } catch (...) {
12282       {
12283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12284       };
12285     }
12286   }
12287
12288 }
12289
12290
12291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
12292   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12293   Dali::Vector3 *arg2 = 0 ;
12294
12295   arg1 = (Dali::Matrix *)jarg1;
12296   arg2 = (Dali::Vector3 *)jarg2;
12297   if (!arg2) {
12298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12299     return ;
12300   }
12301   {
12302     try {
12303       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
12304     } catch (std::out_of_range& e) {
12305       {
12306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12307       };
12308     } catch (std::exception& e) {
12309       {
12310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12311       };
12312     } catch (Dali::DaliException e) {
12313       {
12314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12315       };
12316     } catch (...) {
12317       {
12318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12319       };
12320     }
12321   }
12322
12323 }
12324
12325
12326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
12327   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12328   Dali::Matrix *arg2 = 0 ;
12329
12330   arg1 = (Dali::Matrix *)jarg1;
12331   arg2 = (Dali::Matrix *)jarg2;
12332   if (!arg2) {
12333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12334     return ;
12335   }
12336   {
12337     try {
12338       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
12339     } catch (std::out_of_range& e) {
12340       {
12341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12342       };
12343     } catch (std::exception& e) {
12344       {
12345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12346       };
12347     } catch (Dali::DaliException e) {
12348       {
12349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12350       };
12351     } catch (...) {
12352       {
12353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12354       };
12355     }
12356   }
12357
12358 }
12359
12360
12361 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
12362   unsigned int jresult ;
12363   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12364   bool result;
12365
12366   arg1 = (Dali::Matrix *)jarg1;
12367   {
12368     try {
12369       result = (bool)(arg1)->Invert();
12370     } catch (std::out_of_range& e) {
12371       {
12372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12373       };
12374     } catch (std::exception& e) {
12375       {
12376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12377       };
12378     } catch (Dali::DaliException e) {
12379       {
12380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12381       };
12382     } catch (...) {
12383       {
12384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12385       };
12386     }
12387   }
12388
12389   jresult = result;
12390   return jresult;
12391 }
12392
12393
12394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
12395   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12396
12397   arg1 = (Dali::Matrix *)jarg1;
12398   {
12399     try {
12400       (arg1)->Transpose();
12401     } catch (std::out_of_range& e) {
12402       {
12403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12404       };
12405     } catch (std::exception& e) {
12406       {
12407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12408       };
12409     } catch (Dali::DaliException e) {
12410       {
12411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12412       };
12413     } catch (...) {
12414       {
12415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12416       };
12417     }
12418   }
12419
12420 }
12421
12422
12423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
12424   void * jresult ;
12425   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12426   Dali::Vector3 result;
12427
12428   arg1 = (Dali::Matrix *)jarg1;
12429   {
12430     try {
12431       result = ((Dali::Matrix const *)arg1)->GetXAxis();
12432     } catch (std::out_of_range& e) {
12433       {
12434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12435       };
12436     } catch (std::exception& e) {
12437       {
12438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12439       };
12440     } catch (Dali::DaliException e) {
12441       {
12442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12443       };
12444     } catch (...) {
12445       {
12446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12447       };
12448     }
12449   }
12450
12451   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12452   return jresult;
12453 }
12454
12455
12456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
12457   void * jresult ;
12458   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12459   Dali::Vector3 result;
12460
12461   arg1 = (Dali::Matrix *)jarg1;
12462   {
12463     try {
12464       result = ((Dali::Matrix const *)arg1)->GetYAxis();
12465     } catch (std::out_of_range& e) {
12466       {
12467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12468       };
12469     } catch (std::exception& e) {
12470       {
12471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12472       };
12473     } catch (Dali::DaliException e) {
12474       {
12475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12476       };
12477     } catch (...) {
12478       {
12479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12480       };
12481     }
12482   }
12483
12484   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12485   return jresult;
12486 }
12487
12488
12489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
12490   void * jresult ;
12491   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12492   Dali::Vector3 result;
12493
12494   arg1 = (Dali::Matrix *)jarg1;
12495   {
12496     try {
12497       result = ((Dali::Matrix const *)arg1)->GetZAxis();
12498     } catch (std::out_of_range& e) {
12499       {
12500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12501       };
12502     } catch (std::exception& e) {
12503       {
12504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12505       };
12506     } catch (Dali::DaliException e) {
12507       {
12508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12509       };
12510     } catch (...) {
12511       {
12512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12513       };
12514     }
12515   }
12516
12517   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12518   return jresult;
12519 }
12520
12521
12522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
12523   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12524   Dali::Vector3 *arg2 = 0 ;
12525
12526   arg1 = (Dali::Matrix *)jarg1;
12527   arg2 = (Dali::Vector3 *)jarg2;
12528   if (!arg2) {
12529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12530     return ;
12531   }
12532   {
12533     try {
12534       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
12535     } catch (std::out_of_range& e) {
12536       {
12537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12538       };
12539     } catch (std::exception& e) {
12540       {
12541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12542       };
12543     } catch (Dali::DaliException e) {
12544       {
12545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12546       };
12547     } catch (...) {
12548       {
12549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12550       };
12551     }
12552   }
12553
12554 }
12555
12556
12557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
12558   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12559   Dali::Vector3 *arg2 = 0 ;
12560
12561   arg1 = (Dali::Matrix *)jarg1;
12562   arg2 = (Dali::Vector3 *)jarg2;
12563   if (!arg2) {
12564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12565     return ;
12566   }
12567   {
12568     try {
12569       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
12570     } catch (std::out_of_range& e) {
12571       {
12572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12573       };
12574     } catch (std::exception& e) {
12575       {
12576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12577       };
12578     } catch (Dali::DaliException e) {
12579       {
12580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12581       };
12582     } catch (...) {
12583       {
12584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12585       };
12586     }
12587   }
12588
12589 }
12590
12591
12592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
12593   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12594   Dali::Vector3 *arg2 = 0 ;
12595
12596   arg1 = (Dali::Matrix *)jarg1;
12597   arg2 = (Dali::Vector3 *)jarg2;
12598   if (!arg2) {
12599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12600     return ;
12601   }
12602   {
12603     try {
12604       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
12605     } catch (std::out_of_range& e) {
12606       {
12607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12608       };
12609     } catch (std::exception& e) {
12610       {
12611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12612       };
12613     } catch (Dali::DaliException e) {
12614       {
12615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12616       };
12617     } catch (...) {
12618       {
12619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12620       };
12621     }
12622   }
12623
12624 }
12625
12626
12627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
12628   void * jresult ;
12629   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12630   Dali::Vector4 *result = 0 ;
12631
12632   arg1 = (Dali::Matrix *)jarg1;
12633   {
12634     try {
12635       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
12636     } catch (std::out_of_range& e) {
12637       {
12638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12639       };
12640     } catch (std::exception& e) {
12641       {
12642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12643       };
12644     } catch (Dali::DaliException e) {
12645       {
12646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12647       };
12648     } catch (...) {
12649       {
12650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12651       };
12652     }
12653   }
12654
12655   jresult = (void *)result;
12656   return jresult;
12657 }
12658
12659
12660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
12661   void * jresult ;
12662   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12663   Dali::Vector3 *result = 0 ;
12664
12665   arg1 = (Dali::Matrix *)jarg1;
12666   {
12667     try {
12668       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
12669     } catch (std::out_of_range& e) {
12670       {
12671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12672       };
12673     } catch (std::exception& e) {
12674       {
12675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12676       };
12677     } catch (Dali::DaliException e) {
12678       {
12679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12680       };
12681     } catch (...) {
12682       {
12683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12684       };
12685     }
12686   }
12687
12688   jresult = (void *)result;
12689   return jresult;
12690 }
12691
12692
12693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
12694   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12695   Dali::Vector4 *arg2 = 0 ;
12696
12697   arg1 = (Dali::Matrix *)jarg1;
12698   arg2 = (Dali::Vector4 *)jarg2;
12699   if (!arg2) {
12700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
12701     return ;
12702   }
12703   {
12704     try {
12705       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
12706     } catch (std::out_of_range& e) {
12707       {
12708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12709       };
12710     } catch (std::exception& e) {
12711       {
12712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12713       };
12714     } catch (Dali::DaliException e) {
12715       {
12716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12717       };
12718     } catch (...) {
12719       {
12720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12721       };
12722     }
12723   }
12724
12725 }
12726
12727
12728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
12729   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12730   Dali::Vector3 *arg2 = 0 ;
12731
12732   arg1 = (Dali::Matrix *)jarg1;
12733   arg2 = (Dali::Vector3 *)jarg2;
12734   if (!arg2) {
12735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12736     return ;
12737   }
12738   {
12739     try {
12740       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
12741     } catch (std::out_of_range& e) {
12742       {
12743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12744       };
12745     } catch (std::exception& e) {
12746       {
12747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12748       };
12749     } catch (Dali::DaliException e) {
12750       {
12751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12752       };
12753     } catch (...) {
12754       {
12755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12756       };
12757     }
12758   }
12759
12760 }
12761
12762
12763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
12764   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12765
12766   arg1 = (Dali::Matrix *)jarg1;
12767   {
12768     try {
12769       (arg1)->OrthoNormalize();
12770     } catch (std::out_of_range& e) {
12771       {
12772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12773       };
12774     } catch (std::exception& e) {
12775       {
12776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12777       };
12778     } catch (Dali::DaliException e) {
12779       {
12780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12781       };
12782     } catch (...) {
12783       {
12784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12785       };
12786     }
12787   }
12788
12789 }
12790
12791
12792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
12793   void * jresult ;
12794   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12795   float *result = 0 ;
12796
12797   arg1 = (Dali::Matrix *)jarg1;
12798   {
12799     try {
12800       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
12801     } catch (std::out_of_range& e) {
12802       {
12803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12804       };
12805     } catch (std::exception& e) {
12806       {
12807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12808       };
12809     } catch (Dali::DaliException e) {
12810       {
12811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12812       };
12813     } catch (...) {
12814       {
12815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12816       };
12817     }
12818   }
12819
12820   jresult = (void *)result;
12821   return jresult;
12822 }
12823
12824
12825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
12826   Dali::Matrix *arg1 = 0 ;
12827   Dali::Matrix *arg2 = 0 ;
12828   Dali::Matrix *arg3 = 0 ;
12829
12830   arg1 = (Dali::Matrix *)jarg1;
12831   if (!arg1) {
12832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12833     return ;
12834   }
12835   arg2 = (Dali::Matrix *)jarg2;
12836   if (!arg2) {
12837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12838     return ;
12839   }
12840   arg3 = (Dali::Matrix *)jarg3;
12841   if (!arg3) {
12842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12843     return ;
12844   }
12845   {
12846     try {
12847       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
12848     } catch (std::out_of_range& e) {
12849       {
12850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12851       };
12852     } catch (std::exception& e) {
12853       {
12854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12855       };
12856     } catch (Dali::DaliException e) {
12857       {
12858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12859       };
12860     } catch (...) {
12861       {
12862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12863       };
12864     }
12865   }
12866
12867 }
12868
12869
12870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
12871   Dali::Matrix *arg1 = 0 ;
12872   Dali::Matrix *arg2 = 0 ;
12873   Dali::Quaternion *arg3 = 0 ;
12874
12875   arg1 = (Dali::Matrix *)jarg1;
12876   if (!arg1) {
12877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12878     return ;
12879   }
12880   arg2 = (Dali::Matrix *)jarg2;
12881   if (!arg2) {
12882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12883     return ;
12884   }
12885   arg3 = (Dali::Quaternion *)jarg3;
12886   if (!arg3) {
12887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12888     return ;
12889   }
12890   {
12891     try {
12892       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
12893     } catch (std::out_of_range& e) {
12894       {
12895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12896       };
12897     } catch (std::exception& e) {
12898       {
12899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12900       };
12901     } catch (Dali::DaliException e) {
12902       {
12903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12904       };
12905     } catch (...) {
12906       {
12907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12908       };
12909     }
12910   }
12911
12912 }
12913
12914
12915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
12916   void * jresult ;
12917   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12918   Dali::Vector4 *arg2 = 0 ;
12919   Dali::Vector4 result;
12920
12921   arg1 = (Dali::Matrix *)jarg1;
12922   arg2 = (Dali::Vector4 *)jarg2;
12923   if (!arg2) {
12924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
12925     return 0;
12926   }
12927   {
12928     try {
12929       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
12930     } catch (std::out_of_range& e) {
12931       {
12932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12933       };
12934     } catch (std::exception& e) {
12935       {
12936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12937       };
12938     } catch (Dali::DaliException e) {
12939       {
12940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12941       };
12942     } catch (...) {
12943       {
12944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12945       };
12946     }
12947   }
12948
12949   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
12950   return jresult;
12951 }
12952
12953
12954 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
12955   unsigned int jresult ;
12956   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12957   Dali::Matrix *arg2 = 0 ;
12958   bool result;
12959
12960   arg1 = (Dali::Matrix *)jarg1;
12961   arg2 = (Dali::Matrix *)jarg2;
12962   if (!arg2) {
12963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12964     return 0;
12965   }
12966   {
12967     try {
12968       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
12969     } catch (std::out_of_range& e) {
12970       {
12971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12972       };
12973     } catch (std::exception& e) {
12974       {
12975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12976       };
12977     } catch (Dali::DaliException e) {
12978       {
12979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12980       };
12981     } catch (...) {
12982       {
12983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12984       };
12985     }
12986   }
12987
12988   jresult = result;
12989   return jresult;
12990 }
12991
12992
12993 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
12994   unsigned int jresult ;
12995   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12996   Dali::Matrix *arg2 = 0 ;
12997   bool result;
12998
12999   arg1 = (Dali::Matrix *)jarg1;
13000   arg2 = (Dali::Matrix *)jarg2;
13001   if (!arg2) {
13002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13003     return 0;
13004   }
13005   {
13006     try {
13007       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
13008     } catch (std::out_of_range& e) {
13009       {
13010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13011       };
13012     } catch (std::exception& e) {
13013       {
13014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13015       };
13016     } catch (Dali::DaliException e) {
13017       {
13018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13019       };
13020     } catch (...) {
13021       {
13022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13023       };
13024     }
13025   }
13026
13027   jresult = result;
13028   return jresult;
13029 }
13030
13031
13032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13033   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13034   Dali::Vector3 *arg2 = 0 ;
13035   Dali::Quaternion *arg3 = 0 ;
13036   Dali::Vector3 *arg4 = 0 ;
13037
13038   arg1 = (Dali::Matrix *)jarg1;
13039   arg2 = (Dali::Vector3 *)jarg2;
13040   if (!arg2) {
13041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13042     return ;
13043   }
13044   arg3 = (Dali::Quaternion *)jarg3;
13045   if (!arg3) {
13046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13047     return ;
13048   }
13049   arg4 = (Dali::Vector3 *)jarg4;
13050   if (!arg4) {
13051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13052     return ;
13053   }
13054   {
13055     try {
13056       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13057     } catch (std::out_of_range& e) {
13058       {
13059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13060       };
13061     } catch (std::exception& e) {
13062       {
13063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13064       };
13065     } catch (Dali::DaliException e) {
13066       {
13067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13068       };
13069     } catch (...) {
13070       {
13071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13072       };
13073     }
13074   }
13075
13076 }
13077
13078
13079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13080   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13081   Dali::Vector3 *arg2 = 0 ;
13082   Dali::Quaternion *arg3 = 0 ;
13083   Dali::Vector3 *arg4 = 0 ;
13084
13085   arg1 = (Dali::Matrix *)jarg1;
13086   arg2 = (Dali::Vector3 *)jarg2;
13087   if (!arg2) {
13088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13089     return ;
13090   }
13091   arg3 = (Dali::Quaternion *)jarg3;
13092   if (!arg3) {
13093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13094     return ;
13095   }
13096   arg4 = (Dali::Vector3 *)jarg4;
13097   if (!arg4) {
13098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13099     return ;
13100   }
13101   {
13102     try {
13103       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13104     } catch (std::out_of_range& e) {
13105       {
13106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13107       };
13108     } catch (std::exception& e) {
13109       {
13110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13111       };
13112     } catch (Dali::DaliException e) {
13113       {
13114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13115       };
13116     } catch (...) {
13117       {
13118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13119       };
13120     }
13121   }
13122
13123 }
13124
13125
13126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
13127   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13128   Dali::Vector3 *arg2 = 0 ;
13129   Dali::Vector3 *arg3 = 0 ;
13130   Dali::Vector3 *arg4 = 0 ;
13131   Dali::Vector3 *arg5 = 0 ;
13132
13133   arg1 = (Dali::Matrix *)jarg1;
13134   arg2 = (Dali::Vector3 *)jarg2;
13135   if (!arg2) {
13136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13137     return ;
13138   }
13139   arg3 = (Dali::Vector3 *)jarg3;
13140   if (!arg3) {
13141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13142     return ;
13143   }
13144   arg4 = (Dali::Vector3 *)jarg4;
13145   if (!arg4) {
13146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13147     return ;
13148   }
13149   arg5 = (Dali::Vector3 *)jarg5;
13150   if (!arg5) {
13151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13152     return ;
13153   }
13154   {
13155     try {
13156       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
13157     } catch (std::out_of_range& e) {
13158       {
13159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13160       };
13161     } catch (std::exception& e) {
13162       {
13163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13164       };
13165     } catch (Dali::DaliException e) {
13166       {
13167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13168       };
13169     } catch (...) {
13170       {
13171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13172       };
13173     }
13174   }
13175
13176 }
13177
13178
13179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13180   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13181   Dali::Vector3 *arg2 = 0 ;
13182   Dali::Quaternion *arg3 = 0 ;
13183   Dali::Vector3 *arg4 = 0 ;
13184
13185   arg1 = (Dali::Matrix *)jarg1;
13186   arg2 = (Dali::Vector3 *)jarg2;
13187   if (!arg2) {
13188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13189     return ;
13190   }
13191   arg3 = (Dali::Quaternion *)jarg3;
13192   if (!arg3) {
13193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
13194     return ;
13195   }
13196   arg4 = (Dali::Vector3 *)jarg4;
13197   if (!arg4) {
13198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13199     return ;
13200   }
13201   {
13202     try {
13203       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
13204     } catch (std::out_of_range& e) {
13205       {
13206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13207       };
13208     } catch (std::exception& e) {
13209       {
13210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13211       };
13212     } catch (Dali::DaliException e) {
13213       {
13214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13215       };
13216     } catch (...) {
13217       {
13218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13219       };
13220     }
13221   }
13222
13223 }
13224
13225
13226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
13227   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13228
13229   arg1 = (Dali::Matrix *)jarg1;
13230   {
13231     try {
13232       delete arg1;
13233     } catch (std::out_of_range& e) {
13234       {
13235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13236       };
13237     } catch (std::exception& e) {
13238       {
13239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13240       };
13241     } catch (Dali::DaliException e) {
13242       {
13243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13244       };
13245     } catch (...) {
13246       {
13247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13248       };
13249     }
13250   }
13251
13252 }
13253
13254
13255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
13256   void * jresult ;
13257   Dali::Matrix3 *result = 0 ;
13258
13259   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
13260   jresult = (void *)result;
13261   return jresult;
13262 }
13263
13264
13265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
13266   void * jresult ;
13267   Dali::Matrix3 *result = 0 ;
13268
13269   {
13270     try {
13271       result = (Dali::Matrix3 *)new Dali::Matrix3();
13272     } catch (std::out_of_range& e) {
13273       {
13274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13275       };
13276     } catch (std::exception& e) {
13277       {
13278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13279       };
13280     } catch (Dali::DaliException e) {
13281       {
13282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13283       };
13284     } catch (...) {
13285       {
13286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13287       };
13288     }
13289   }
13290
13291   jresult = (void *)result;
13292   return jresult;
13293 }
13294
13295
13296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
13297   void * jresult ;
13298   Dali::Matrix3 *arg1 = 0 ;
13299   Dali::Matrix3 *result = 0 ;
13300
13301   arg1 = (Dali::Matrix3 *)jarg1;
13302   if (!arg1) {
13303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13304     return 0;
13305   }
13306   {
13307     try {
13308       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
13309     } catch (std::out_of_range& e) {
13310       {
13311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13312       };
13313     } catch (std::exception& e) {
13314       {
13315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13316       };
13317     } catch (Dali::DaliException e) {
13318       {
13319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13320       };
13321     } catch (...) {
13322       {
13323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13324       };
13325     }
13326   }
13327
13328   jresult = (void *)result;
13329   return jresult;
13330 }
13331
13332
13333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
13334   void * jresult ;
13335   Dali::Matrix *arg1 = 0 ;
13336   Dali::Matrix3 *result = 0 ;
13337
13338   arg1 = (Dali::Matrix *)jarg1;
13339   if (!arg1) {
13340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13341     return 0;
13342   }
13343   {
13344     try {
13345       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
13346     } catch (std::out_of_range& e) {
13347       {
13348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13349       };
13350     } catch (std::exception& e) {
13351       {
13352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13353       };
13354     } catch (Dali::DaliException e) {
13355       {
13356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13357       };
13358     } catch (...) {
13359       {
13360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13361       };
13362     }
13363   }
13364
13365   jresult = (void *)result;
13366   return jresult;
13367 }
13368
13369
13370 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) {
13371   void * jresult ;
13372   float arg1 ;
13373   float arg2 ;
13374   float arg3 ;
13375   float arg4 ;
13376   float arg5 ;
13377   float arg6 ;
13378   float arg7 ;
13379   float arg8 ;
13380   float arg9 ;
13381   Dali::Matrix3 *result = 0 ;
13382
13383   arg1 = (float)jarg1;
13384   arg2 = (float)jarg2;
13385   arg3 = (float)jarg3;
13386   arg4 = (float)jarg4;
13387   arg5 = (float)jarg5;
13388   arg6 = (float)jarg6;
13389   arg7 = (float)jarg7;
13390   arg8 = (float)jarg8;
13391   arg9 = (float)jarg9;
13392   {
13393     try {
13394       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
13395     } catch (std::out_of_range& e) {
13396       {
13397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13398       };
13399     } catch (std::exception& e) {
13400       {
13401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13402       };
13403     } catch (Dali::DaliException e) {
13404       {
13405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13406       };
13407     } catch (...) {
13408       {
13409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13410       };
13411     }
13412   }
13413
13414   jresult = (void *)result;
13415   return jresult;
13416 }
13417
13418
13419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
13420   void * jresult ;
13421   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13422   Dali::Matrix3 *arg2 = 0 ;
13423   Dali::Matrix3 *result = 0 ;
13424
13425   arg1 = (Dali::Matrix3 *)jarg1;
13426   arg2 = (Dali::Matrix3 *)jarg2;
13427   if (!arg2) {
13428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13429     return 0;
13430   }
13431   {
13432     try {
13433       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
13434     } catch (std::out_of_range& e) {
13435       {
13436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13437       };
13438     } catch (std::exception& e) {
13439       {
13440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13441       };
13442     } catch (Dali::DaliException e) {
13443       {
13444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13445       };
13446     } catch (...) {
13447       {
13448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13449       };
13450     }
13451   }
13452
13453   jresult = (void *)result;
13454   return jresult;
13455 }
13456
13457
13458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
13459   void * jresult ;
13460   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13461   Dali::Matrix *arg2 = 0 ;
13462   Dali::Matrix3 *result = 0 ;
13463
13464   arg1 = (Dali::Matrix3 *)jarg1;
13465   arg2 = (Dali::Matrix *)jarg2;
13466   if (!arg2) {
13467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13468     return 0;
13469   }
13470   {
13471     try {
13472       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
13473     } catch (std::out_of_range& e) {
13474       {
13475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13476       };
13477     } catch (std::exception& e) {
13478       {
13479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13480       };
13481     } catch (Dali::DaliException e) {
13482       {
13483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13484       };
13485     } catch (...) {
13486       {
13487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13488       };
13489     }
13490   }
13491
13492   jresult = (void *)result;
13493   return jresult;
13494 }
13495
13496
13497 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
13498   unsigned int jresult ;
13499   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13500   Dali::Matrix3 *arg2 = 0 ;
13501   bool result;
13502
13503   arg1 = (Dali::Matrix3 *)jarg1;
13504   arg2 = (Dali::Matrix3 *)jarg2;
13505   if (!arg2) {
13506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13507     return 0;
13508   }
13509   {
13510     try {
13511       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
13512     } catch (std::out_of_range& e) {
13513       {
13514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13515       };
13516     } catch (std::exception& e) {
13517       {
13518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13519       };
13520     } catch (Dali::DaliException e) {
13521       {
13522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13523       };
13524     } catch (...) {
13525       {
13526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13527       };
13528     }
13529   }
13530
13531   jresult = result;
13532   return jresult;
13533 }
13534
13535
13536 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
13537   unsigned int jresult ;
13538   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13539   Dali::Matrix3 *arg2 = 0 ;
13540   bool result;
13541
13542   arg1 = (Dali::Matrix3 *)jarg1;
13543   arg2 = (Dali::Matrix3 *)jarg2;
13544   if (!arg2) {
13545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13546     return 0;
13547   }
13548   {
13549     try {
13550       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
13551     } catch (std::out_of_range& e) {
13552       {
13553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13554       };
13555     } catch (std::exception& e) {
13556       {
13557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13558       };
13559     } catch (Dali::DaliException e) {
13560       {
13561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13562       };
13563     } catch (...) {
13564       {
13565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13566       };
13567     }
13568   }
13569
13570   jresult = result;
13571   return jresult;
13572 }
13573
13574
13575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
13576   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13577
13578   arg1 = (Dali::Matrix3 *)jarg1;
13579   {
13580     try {
13581       delete arg1;
13582     } catch (std::out_of_range& e) {
13583       {
13584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13585       };
13586     } catch (std::exception& e) {
13587       {
13588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13589       };
13590     } catch (Dali::DaliException e) {
13591       {
13592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13593       };
13594     } catch (...) {
13595       {
13596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13597       };
13598     }
13599   }
13600
13601 }
13602
13603
13604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
13605   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13606
13607   arg1 = (Dali::Matrix3 *)jarg1;
13608   {
13609     try {
13610       (arg1)->SetIdentity();
13611     } catch (std::out_of_range& e) {
13612       {
13613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13614       };
13615     } catch (std::exception& e) {
13616       {
13617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13618       };
13619     } catch (Dali::DaliException e) {
13620       {
13621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13622       };
13623     } catch (...) {
13624       {
13625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13626       };
13627     }
13628   }
13629
13630 }
13631
13632
13633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
13634   void * jresult ;
13635   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13636   float *result = 0 ;
13637
13638   arg1 = (Dali::Matrix3 *)jarg1;
13639   {
13640     try {
13641       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
13642     } catch (std::out_of_range& e) {
13643       {
13644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13645       };
13646     } catch (std::exception& e) {
13647       {
13648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13649       };
13650     } catch (Dali::DaliException e) {
13651       {
13652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13653       };
13654     } catch (...) {
13655       {
13656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13657       };
13658     }
13659   }
13660
13661   jresult = (void *)result;
13662   return jresult;
13663 }
13664
13665
13666 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
13667   unsigned int jresult ;
13668   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13669   bool result;
13670
13671   arg1 = (Dali::Matrix3 *)jarg1;
13672   {
13673     try {
13674       result = (bool)(arg1)->Invert();
13675     } catch (std::out_of_range& e) {
13676       {
13677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13678       };
13679     } catch (std::exception& e) {
13680       {
13681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13682       };
13683     } catch (Dali::DaliException e) {
13684       {
13685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13686       };
13687     } catch (...) {
13688       {
13689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13690       };
13691     }
13692   }
13693
13694   jresult = result;
13695   return jresult;
13696 }
13697
13698
13699 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
13700   unsigned int jresult ;
13701   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13702   bool result;
13703
13704   arg1 = (Dali::Matrix3 *)jarg1;
13705   {
13706     try {
13707       result = (bool)(arg1)->Transpose();
13708     } catch (std::out_of_range& e) {
13709       {
13710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13711       };
13712     } catch (std::exception& e) {
13713       {
13714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13715       };
13716     } catch (Dali::DaliException e) {
13717       {
13718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13719       };
13720     } catch (...) {
13721       {
13722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13723       };
13724     }
13725   }
13726
13727   jresult = result;
13728   return jresult;
13729 }
13730
13731
13732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
13733   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13734   float arg2 ;
13735
13736   arg1 = (Dali::Matrix3 *)jarg1;
13737   arg2 = (float)jarg2;
13738   {
13739     try {
13740       (arg1)->Scale(arg2);
13741     } catch (std::out_of_range& e) {
13742       {
13743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13744       };
13745     } catch (std::exception& e) {
13746       {
13747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13748       };
13749     } catch (Dali::DaliException e) {
13750       {
13751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13752       };
13753     } catch (...) {
13754       {
13755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13756       };
13757     }
13758   }
13759
13760 }
13761
13762
13763 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
13764   float jresult ;
13765   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13766   float result;
13767
13768   arg1 = (Dali::Matrix3 *)jarg1;
13769   {
13770     try {
13771       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
13772     } catch (std::out_of_range& e) {
13773       {
13774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13775       };
13776     } catch (std::exception& e) {
13777       {
13778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13779       };
13780     } catch (Dali::DaliException e) {
13781       {
13782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13783       };
13784     } catch (...) {
13785       {
13786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13787       };
13788     }
13789   }
13790
13791   jresult = result;
13792   return jresult;
13793 }
13794
13795
13796 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
13797   unsigned int jresult ;
13798   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13799   bool result;
13800
13801   arg1 = (Dali::Matrix3 *)jarg1;
13802   {
13803     try {
13804       result = (bool)(arg1)->ScaledInverseTranspose();
13805     } catch (std::out_of_range& e) {
13806       {
13807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13808       };
13809     } catch (std::exception& e) {
13810       {
13811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13812       };
13813     } catch (Dali::DaliException e) {
13814       {
13815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13816       };
13817     } catch (...) {
13818       {
13819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13820       };
13821     }
13822   }
13823
13824   jresult = result;
13825   return jresult;
13826 }
13827
13828
13829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
13830   Dali::Matrix3 *arg1 = 0 ;
13831   Dali::Matrix3 *arg2 = 0 ;
13832   Dali::Matrix3 *arg3 = 0 ;
13833
13834   arg1 = (Dali::Matrix3 *)jarg1;
13835   if (!arg1) {
13836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
13837     return ;
13838   }
13839   arg2 = (Dali::Matrix3 *)jarg2;
13840   if (!arg2) {
13841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13842     return ;
13843   }
13844   arg3 = (Dali::Matrix3 *)jarg3;
13845   if (!arg3) {
13846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13847     return ;
13848   }
13849   {
13850     try {
13851       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
13852     } catch (std::out_of_range& e) {
13853       {
13854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13855       };
13856     } catch (std::exception& e) {
13857       {
13858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13859       };
13860     } catch (Dali::DaliException e) {
13861       {
13862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13863       };
13864     } catch (...) {
13865       {
13866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13867       };
13868     }
13869   }
13870
13871 }
13872
13873
13874 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
13875   float jresult ;
13876   float arg1 ;
13877   float arg2 ;
13878   float result;
13879
13880   arg1 = (float)jarg1;
13881   arg2 = (float)jarg2;
13882   {
13883     try {
13884       result = (float)Dali::Random::Range(arg1,arg2);
13885     } catch (std::out_of_range& e) {
13886       {
13887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13888       };
13889     } catch (std::exception& e) {
13890       {
13891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13892       };
13893     } catch (Dali::DaliException e) {
13894       {
13895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13896       };
13897     } catch (...) {
13898       {
13899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13900       };
13901     }
13902   }
13903
13904   jresult = result;
13905   return jresult;
13906 }
13907
13908
13909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
13910   void * jresult ;
13911   Dali::Vector4 result;
13912
13913   {
13914     try {
13915       result = Dali::Random::Axis();
13916     } catch (std::out_of_range& e) {
13917       {
13918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13919       };
13920     } catch (std::exception& e) {
13921       {
13922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13923       };
13924     } catch (Dali::DaliException e) {
13925       {
13926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13927       };
13928     } catch (...) {
13929       {
13930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13931       };
13932     }
13933   }
13934
13935   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
13936   return jresult;
13937 }
13938
13939
13940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
13941   void * jresult ;
13942   Dali::AngleAxis *result = 0 ;
13943
13944   {
13945     try {
13946       result = (Dali::AngleAxis *)new Dali::AngleAxis();
13947     } catch (std::out_of_range& e) {
13948       {
13949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13950       };
13951     } catch (std::exception& e) {
13952       {
13953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13954       };
13955     } catch (Dali::DaliException e) {
13956       {
13957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13958       };
13959     } catch (...) {
13960       {
13961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13962       };
13963     }
13964   }
13965
13966   jresult = (void *)result;
13967   return jresult;
13968 }
13969
13970
13971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
13972   void * jresult ;
13973   Dali::Radian arg1 ;
13974   Dali::Vector3 *arg2 = 0 ;
13975   Dali::Radian *argp1 ;
13976   Dali::AngleAxis *result = 0 ;
13977
13978   argp1 = (Dali::Radian *)jarg1;
13979   if (!argp1) {
13980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
13981     return 0;
13982   }
13983   arg1 = *argp1;
13984   arg2 = (Dali::Vector3 *)jarg2;
13985   if (!arg2) {
13986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13987     return 0;
13988   }
13989   {
13990     try {
13991       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
13992     } catch (std::out_of_range& e) {
13993       {
13994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13995       };
13996     } catch (std::exception& e) {
13997       {
13998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13999       };
14000     } catch (Dali::DaliException e) {
14001       {
14002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14003       };
14004     } catch (...) {
14005       {
14006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14007       };
14008     }
14009   }
14010
14011   jresult = (void *)result;
14012   return jresult;
14013 }
14014
14015
14016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
14017   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14018   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
14019
14020   arg1 = (Dali::AngleAxis *)jarg1;
14021   arg2 = (Dali::Radian *)jarg2;
14022   if (arg1) (arg1)->angle = *arg2;
14023 }
14024
14025
14026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
14027   void * jresult ;
14028   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14029   Dali::Radian *result = 0 ;
14030
14031   arg1 = (Dali::AngleAxis *)jarg1;
14032   result = (Dali::Radian *)& ((arg1)->angle);
14033   jresult = (void *)result;
14034   return jresult;
14035 }
14036
14037
14038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
14039   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14040   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
14041
14042   arg1 = (Dali::AngleAxis *)jarg1;
14043   arg2 = (Dali::Vector3 *)jarg2;
14044   if (arg1) (arg1)->axis = *arg2;
14045 }
14046
14047
14048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
14049   void * jresult ;
14050   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14051   Dali::Vector3 *result = 0 ;
14052
14053   arg1 = (Dali::AngleAxis *)jarg1;
14054   result = (Dali::Vector3 *)& ((arg1)->axis);
14055   jresult = (void *)result;
14056   return jresult;
14057 }
14058
14059
14060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
14061   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14062
14063   arg1 = (Dali::AngleAxis *)jarg1;
14064   {
14065     try {
14066       delete arg1;
14067     } catch (std::out_of_range& e) {
14068       {
14069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14070       };
14071     } catch (std::exception& e) {
14072       {
14073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14074       };
14075     } catch (Dali::DaliException e) {
14076       {
14077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14078       };
14079     } catch (...) {
14080       {
14081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14082       };
14083     }
14084   }
14085
14086 }
14087
14088
14089 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
14090   unsigned int jresult ;
14091   Dali::AngleAxis *arg1 = 0 ;
14092   Dali::AngleAxis *arg2 = 0 ;
14093   bool result;
14094
14095   arg1 = (Dali::AngleAxis *)jarg1;
14096   if (!arg1) {
14097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14098     return 0;
14099   }
14100   arg2 = (Dali::AngleAxis *)jarg2;
14101   if (!arg2) {
14102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14103     return 0;
14104   }
14105   {
14106     try {
14107       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
14108     } catch (std::out_of_range& e) {
14109       {
14110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14111       };
14112     } catch (std::exception& e) {
14113       {
14114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14115       };
14116     } catch (Dali::DaliException e) {
14117       {
14118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14119       };
14120     } catch (...) {
14121       {
14122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14123       };
14124     }
14125   }
14126
14127   jresult = result;
14128   return jresult;
14129 }
14130
14131
14132 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
14133   unsigned int jresult ;
14134   unsigned int arg1 ;
14135   unsigned int result;
14136
14137   arg1 = (unsigned int)jarg1;
14138   {
14139     try {
14140       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
14141     } catch (std::out_of_range& e) {
14142       {
14143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14144       };
14145     } catch (std::exception& e) {
14146       {
14147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14148       };
14149     } catch (Dali::DaliException e) {
14150       {
14151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14152       };
14153     } catch (...) {
14154       {
14155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14156       };
14157     }
14158   }
14159
14160   jresult = result;
14161   return jresult;
14162 }
14163
14164
14165 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
14166   unsigned int jresult ;
14167   unsigned int arg1 ;
14168   bool result;
14169
14170   arg1 = (unsigned int)jarg1;
14171   {
14172     try {
14173       result = (bool)Dali::IsPowerOfTwo(arg1);
14174     } catch (std::out_of_range& e) {
14175       {
14176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14177       };
14178     } catch (std::exception& e) {
14179       {
14180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14181       };
14182     } catch (Dali::DaliException e) {
14183       {
14184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14185       };
14186     } catch (...) {
14187       {
14188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14189       };
14190     }
14191   }
14192
14193   jresult = result;
14194   return jresult;
14195 }
14196
14197
14198 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
14199   float jresult ;
14200   float arg1 ;
14201   float arg2 ;
14202   float result;
14203
14204   arg1 = (float)jarg1;
14205   arg2 = (float)jarg2;
14206   {
14207     try {
14208       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
14209     } catch (std::out_of_range& e) {
14210       {
14211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14212       };
14213     } catch (std::exception& e) {
14214       {
14215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14216       };
14217     } catch (Dali::DaliException e) {
14218       {
14219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14220       };
14221     } catch (...) {
14222       {
14223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14224       };
14225     }
14226   }
14227
14228   jresult = result;
14229   return jresult;
14230 }
14231
14232
14233 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
14234   unsigned int jresult ;
14235   float arg1 ;
14236   bool result;
14237
14238   arg1 = (float)jarg1;
14239   {
14240     try {
14241       result = (bool)Dali::EqualsZero(arg1);
14242     } catch (std::out_of_range& e) {
14243       {
14244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14245       };
14246     } catch (std::exception& e) {
14247       {
14248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14249       };
14250     } catch (Dali::DaliException e) {
14251       {
14252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14253       };
14254     } catch (...) {
14255       {
14256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14257       };
14258     }
14259   }
14260
14261   jresult = result;
14262   return jresult;
14263 }
14264
14265
14266 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
14267   unsigned int jresult ;
14268   float arg1 ;
14269   float arg2 ;
14270   bool result;
14271
14272   arg1 = (float)jarg1;
14273   arg2 = (float)jarg2;
14274   {
14275     try {
14276       result = (bool)Dali::Equals(arg1,arg2);
14277     } catch (std::out_of_range& e) {
14278       {
14279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14280       };
14281     } catch (std::exception& e) {
14282       {
14283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14284       };
14285     } catch (Dali::DaliException e) {
14286       {
14287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14288       };
14289     } catch (...) {
14290       {
14291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14292       };
14293     }
14294   }
14295
14296   jresult = result;
14297   return jresult;
14298 }
14299
14300
14301 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
14302   unsigned int jresult ;
14303   float arg1 ;
14304   float arg2 ;
14305   float arg3 ;
14306   bool result;
14307
14308   arg1 = (float)jarg1;
14309   arg2 = (float)jarg2;
14310   arg3 = (float)jarg3;
14311   {
14312     try {
14313       result = (bool)Dali::Equals(arg1,arg2,arg3);
14314     } catch (std::out_of_range& e) {
14315       {
14316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14317       };
14318     } catch (std::exception& e) {
14319       {
14320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14321       };
14322     } catch (Dali::DaliException e) {
14323       {
14324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14325       };
14326     } catch (...) {
14327       {
14328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14329       };
14330     }
14331   }
14332
14333   jresult = result;
14334   return jresult;
14335 }
14336
14337
14338 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
14339   float jresult ;
14340   float arg1 ;
14341   int arg2 ;
14342   float result;
14343
14344   arg1 = (float)jarg1;
14345   arg2 = (int)jarg2;
14346   {
14347     try {
14348       result = (float)Dali::Round(arg1,arg2);
14349     } catch (std::out_of_range& e) {
14350       {
14351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14352       };
14353     } catch (std::exception& e) {
14354       {
14355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14356       };
14357     } catch (Dali::DaliException e) {
14358       {
14359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14360       };
14361     } catch (...) {
14362       {
14363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14364       };
14365     }
14366   }
14367
14368   jresult = result;
14369   return jresult;
14370 }
14371
14372
14373 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
14374   float jresult ;
14375   float arg1 ;
14376   float arg2 ;
14377   float arg3 ;
14378   float result;
14379
14380   arg1 = (float)jarg1;
14381   arg2 = (float)jarg2;
14382   arg3 = (float)jarg3;
14383   {
14384     try {
14385       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
14386     } catch (std::out_of_range& e) {
14387       {
14388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14389       };
14390     } catch (std::exception& e) {
14391       {
14392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14393       };
14394     } catch (Dali::DaliException e) {
14395       {
14396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14397       };
14398     } catch (...) {
14399       {
14400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14401       };
14402     }
14403   }
14404
14405   jresult = result;
14406   return jresult;
14407 }
14408
14409
14410 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
14411   float jresult ;
14412   float arg1 ;
14413   float arg2 ;
14414   float arg3 ;
14415   float arg4 ;
14416   float result;
14417
14418   arg1 = (float)jarg1;
14419   arg2 = (float)jarg2;
14420   arg3 = (float)jarg3;
14421   arg4 = (float)jarg4;
14422   {
14423     try {
14424       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
14425     } catch (std::out_of_range& e) {
14426       {
14427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14428       };
14429     } catch (std::exception& e) {
14430       {
14431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14432       };
14433     } catch (Dali::DaliException e) {
14434       {
14435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14436       };
14437     } catch (...) {
14438       {
14439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14440       };
14441     }
14442   }
14443
14444   jresult = result;
14445   return jresult;
14446 }
14447
14448
14449 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
14450   int jresult ;
14451   int result;
14452
14453   result = (int)(int)Dali::Property::INVALID_INDEX;
14454   jresult = result;
14455   return jresult;
14456 }
14457
14458
14459 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
14460   int jresult ;
14461   int result;
14462
14463   result = (int)(int)Dali::Property::INVALID_KEY;
14464   jresult = result;
14465   return jresult;
14466 }
14467
14468
14469 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
14470   int jresult ;
14471   int result;
14472
14473   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
14474   jresult = result;
14475   return jresult;
14476 }
14477
14478
14479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
14480   void * jresult ;
14481   Dali::Handle *arg1 = 0 ;
14482   Dali::Property::Index arg2 ;
14483   Dali::Property *result = 0 ;
14484
14485   arg1 = (Dali::Handle *)jarg1;
14486   if (!arg1) {
14487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14488     return 0;
14489   }
14490   arg2 = (Dali::Property::Index)jarg2;
14491   {
14492     try {
14493       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
14494     } catch (std::out_of_range& e) {
14495       {
14496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14497       };
14498     } catch (std::exception& e) {
14499       {
14500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14501       };
14502     } catch (Dali::DaliException e) {
14503       {
14504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14505       };
14506     } catch (...) {
14507       {
14508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14509       };
14510     }
14511   }
14512
14513   jresult = (void *)result;
14514   return jresult;
14515 }
14516
14517
14518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
14519   void * jresult ;
14520   Dali::Handle *arg1 = 0 ;
14521   Dali::Property::Index arg2 ;
14522   int arg3 ;
14523   Dali::Property *result = 0 ;
14524
14525   arg1 = (Dali::Handle *)jarg1;
14526   if (!arg1) {
14527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14528     return 0;
14529   }
14530   arg2 = (Dali::Property::Index)jarg2;
14531   arg3 = (int)jarg3;
14532   {
14533     try {
14534       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
14535     } catch (std::out_of_range& e) {
14536       {
14537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14538       };
14539     } catch (std::exception& e) {
14540       {
14541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14542       };
14543     } catch (Dali::DaliException e) {
14544       {
14545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14546       };
14547     } catch (...) {
14548       {
14549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14550       };
14551     }
14552   }
14553
14554   jresult = (void *)result;
14555   return jresult;
14556 }
14557
14558
14559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
14560   void * jresult ;
14561   Dali::Handle *arg1 = 0 ;
14562   std::string *arg2 = 0 ;
14563   Dali::Property *result = 0 ;
14564
14565   arg1 = (Dali::Handle *)jarg1;
14566   if (!arg1) {
14567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14568     return 0;
14569   }
14570   if (!jarg2) {
14571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14572     return 0;
14573   }
14574   std::string arg2_str(jarg2);
14575   arg2 = &arg2_str;
14576   {
14577     try {
14578       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
14579     } catch (std::out_of_range& e) {
14580       {
14581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14582       };
14583     } catch (std::exception& e) {
14584       {
14585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14586       };
14587     } catch (Dali::DaliException e) {
14588       {
14589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14590       };
14591     } catch (...) {
14592       {
14593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14594       };
14595     }
14596   }
14597
14598   jresult = (void *)result;
14599
14600   //argout typemap for const std::string&
14601
14602   return jresult;
14603 }
14604
14605
14606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
14607   void * jresult ;
14608   Dali::Handle *arg1 = 0 ;
14609   std::string *arg2 = 0 ;
14610   int arg3 ;
14611   Dali::Property *result = 0 ;
14612
14613   arg1 = (Dali::Handle *)jarg1;
14614   if (!arg1) {
14615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14616     return 0;
14617   }
14618   if (!jarg2) {
14619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14620     return 0;
14621   }
14622   std::string arg2_str(jarg2);
14623   arg2 = &arg2_str;
14624   arg3 = (int)jarg3;
14625   {
14626     try {
14627       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
14628     } catch (std::out_of_range& e) {
14629       {
14630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14631       };
14632     } catch (std::exception& e) {
14633       {
14634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14635       };
14636     } catch (Dali::DaliException e) {
14637       {
14638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14639       };
14640     } catch (...) {
14641       {
14642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14643       };
14644     }
14645   }
14646
14647   jresult = (void *)result;
14648
14649   //argout typemap for const std::string&
14650
14651   return jresult;
14652 }
14653
14654
14655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
14656   Dali::Property *arg1 = (Dali::Property *) 0 ;
14657
14658   arg1 = (Dali::Property *)jarg1;
14659   {
14660     try {
14661       delete arg1;
14662     } catch (std::out_of_range& e) {
14663       {
14664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14665       };
14666     } catch (std::exception& e) {
14667       {
14668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14669       };
14670     } catch (Dali::DaliException e) {
14671       {
14672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14673       };
14674     } catch (...) {
14675       {
14676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14677       };
14678     }
14679   }
14680
14681 }
14682
14683
14684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
14685   Dali::Property *arg1 = (Dali::Property *) 0 ;
14686   Dali::Handle *arg2 = 0 ;
14687
14688   arg1 = (Dali::Property *)jarg1;
14689   arg2 = (Dali::Handle *)jarg2;
14690   if (!arg2) {
14691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14692     return ;
14693   }
14694   if (arg1) (arg1)->object = *arg2;
14695 }
14696
14697
14698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
14699   void * jresult ;
14700   Dali::Property *arg1 = (Dali::Property *) 0 ;
14701   Dali::Handle *result = 0 ;
14702
14703   arg1 = (Dali::Property *)jarg1;
14704   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
14705   jresult = (void *)result;
14706   return jresult;
14707 }
14708
14709
14710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
14711   Dali::Property *arg1 = (Dali::Property *) 0 ;
14712   Dali::Property::Index arg2 ;
14713
14714   arg1 = (Dali::Property *)jarg1;
14715   arg2 = (Dali::Property::Index)jarg2;
14716   if (arg1) (arg1)->propertyIndex = arg2;
14717 }
14718
14719
14720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
14721   int jresult ;
14722   Dali::Property *arg1 = (Dali::Property *) 0 ;
14723   Dali::Property::Index result;
14724
14725   arg1 = (Dali::Property *)jarg1;
14726   result = (Dali::Property::Index) ((arg1)->propertyIndex);
14727   jresult = result;
14728   return jresult;
14729 }
14730
14731
14732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
14733   Dali::Property *arg1 = (Dali::Property *) 0 ;
14734   int arg2 ;
14735
14736   arg1 = (Dali::Property *)jarg1;
14737   arg2 = (int)jarg2;
14738   if (arg1) (arg1)->componentIndex = arg2;
14739 }
14740
14741
14742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
14743   int jresult ;
14744   Dali::Property *arg1 = (Dali::Property *) 0 ;
14745   int result;
14746
14747   arg1 = (Dali::Property *)jarg1;
14748   result = (int) ((arg1)->componentIndex);
14749   jresult = result;
14750   return jresult;
14751 }
14752
14753
14754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
14755   void * jresult ;
14756   Dali::Property::Array *result = 0 ;
14757
14758   {
14759     try {
14760       result = (Dali::Property::Array *)new Dali::Property::Array();
14761     } catch (std::out_of_range& e) {
14762       {
14763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14764       };
14765     } catch (std::exception& e) {
14766       {
14767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14768       };
14769     } catch (Dali::DaliException e) {
14770       {
14771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14772       };
14773     } catch (...) {
14774       {
14775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14776       };
14777     }
14778   }
14779
14780   jresult = (void *)result;
14781   return jresult;
14782 }
14783
14784
14785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
14786   void * jresult ;
14787   Dali::Property::Array *arg1 = 0 ;
14788   Dali::Property::Array *result = 0 ;
14789
14790   arg1 = (Dali::Property::Array *)jarg1;
14791   if (!arg1) {
14792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
14793     return 0;
14794   }
14795   {
14796     try {
14797       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
14798     } catch (std::out_of_range& e) {
14799       {
14800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14801       };
14802     } catch (std::exception& e) {
14803       {
14804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14805       };
14806     } catch (Dali::DaliException e) {
14807       {
14808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14809       };
14810     } catch (...) {
14811       {
14812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14813       };
14814     }
14815   }
14816
14817   jresult = (void *)result;
14818   return jresult;
14819 }
14820
14821
14822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
14823   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14824
14825   arg1 = (Dali::Property::Array *)jarg1;
14826   {
14827     try {
14828       delete arg1;
14829     } catch (std::out_of_range& e) {
14830       {
14831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14832       };
14833     } catch (std::exception& e) {
14834       {
14835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14836       };
14837     } catch (Dali::DaliException e) {
14838       {
14839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14840       };
14841     } catch (...) {
14842       {
14843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14844       };
14845     }
14846   }
14847
14848 }
14849
14850
14851 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
14852   unsigned long jresult ;
14853   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14854   Dali::Property::Array::SizeType result;
14855
14856   arg1 = (Dali::Property::Array *)jarg1;
14857   {
14858     try {
14859       result = ((Dali::Property::Array const *)arg1)->Size();
14860     } catch (std::out_of_range& e) {
14861       {
14862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14863       };
14864     } catch (std::exception& e) {
14865       {
14866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14867       };
14868     } catch (Dali::DaliException e) {
14869       {
14870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14871       };
14872     } catch (...) {
14873       {
14874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14875       };
14876     }
14877   }
14878
14879   jresult = (unsigned long)result;
14880   return jresult;
14881 }
14882
14883
14884 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
14885   unsigned long jresult ;
14886   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14887   Dali::Property::Array::SizeType result;
14888
14889   arg1 = (Dali::Property::Array *)jarg1;
14890   {
14891     try {
14892       result = ((Dali::Property::Array const *)arg1)->Count();
14893     } catch (std::out_of_range& e) {
14894       {
14895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14896       };
14897     } catch (std::exception& e) {
14898       {
14899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14900       };
14901     } catch (Dali::DaliException e) {
14902       {
14903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14904       };
14905     } catch (...) {
14906       {
14907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14908       };
14909     }
14910   }
14911
14912   jresult = (unsigned long)result;
14913   return jresult;
14914 }
14915
14916
14917 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
14918   unsigned int jresult ;
14919   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14920   bool result;
14921
14922   arg1 = (Dali::Property::Array *)jarg1;
14923   {
14924     try {
14925       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
14926     } catch (std::out_of_range& e) {
14927       {
14928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14929       };
14930     } catch (std::exception& e) {
14931       {
14932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14933       };
14934     } catch (Dali::DaliException e) {
14935       {
14936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14937       };
14938     } catch (...) {
14939       {
14940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14941       };
14942     }
14943   }
14944
14945   jresult = result;
14946   return jresult;
14947 }
14948
14949
14950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
14951   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14952
14953   arg1 = (Dali::Property::Array *)jarg1;
14954   {
14955     try {
14956       (arg1)->Clear();
14957     } catch (std::out_of_range& e) {
14958       {
14959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14960       };
14961     } catch (std::exception& e) {
14962       {
14963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14964       };
14965     } catch (Dali::DaliException e) {
14966       {
14967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14968       };
14969     } catch (...) {
14970       {
14971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14972       };
14973     }
14974   }
14975
14976 }
14977
14978
14979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
14980   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14981   Dali::Property::Array::SizeType arg2 ;
14982
14983   arg1 = (Dali::Property::Array *)jarg1;
14984   arg2 = (Dali::Property::Array::SizeType)jarg2;
14985   {
14986     try {
14987       (arg1)->Reserve(arg2);
14988     } catch (std::out_of_range& e) {
14989       {
14990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14991       };
14992     } catch (std::exception& e) {
14993       {
14994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14995       };
14996     } catch (Dali::DaliException e) {
14997       {
14998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14999       };
15000     } catch (...) {
15001       {
15002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15003       };
15004     }
15005   }
15006
15007 }
15008
15009
15010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
15011   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15012   Dali::Property::Array::SizeType arg2 ;
15013
15014   arg1 = (Dali::Property::Array *)jarg1;
15015   arg2 = (Dali::Property::Array::SizeType)jarg2;
15016   {
15017     try {
15018       (arg1)->Resize(arg2);
15019     } catch (std::out_of_range& e) {
15020       {
15021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15022       };
15023     } catch (std::exception& e) {
15024       {
15025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15026       };
15027     } catch (Dali::DaliException e) {
15028       {
15029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15030       };
15031     } catch (...) {
15032       {
15033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15034       };
15035     }
15036   }
15037
15038 }
15039
15040
15041 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
15042   unsigned long jresult ;
15043   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15044   Dali::Property::Array::SizeType result;
15045
15046   arg1 = (Dali::Property::Array *)jarg1;
15047   {
15048     try {
15049       result = (arg1)->Capacity();
15050     } catch (std::out_of_range& e) {
15051       {
15052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15053       };
15054     } catch (std::exception& e) {
15055       {
15056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15057       };
15058     } catch (Dali::DaliException e) {
15059       {
15060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15061       };
15062     } catch (...) {
15063       {
15064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15065       };
15066     }
15067   }
15068
15069   jresult = (unsigned long)result;
15070   return jresult;
15071 }
15072
15073
15074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
15075   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15076   Dali::Property::Value *arg2 = 0 ;
15077
15078   arg1 = (Dali::Property::Array *)jarg1;
15079   arg2 = (Dali::Property::Value *)jarg2;
15080   if (!arg2) {
15081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15082     return ;
15083   }
15084   {
15085     try {
15086       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
15087     } catch (std::out_of_range& e) {
15088       {
15089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15090       };
15091     } catch (std::exception& e) {
15092       {
15093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15094       };
15095     } catch (Dali::DaliException e) {
15096       {
15097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15098       };
15099     } catch (...) {
15100       {
15101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15102       };
15103     }
15104   }
15105
15106 }
15107
15108
15109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
15110   void * jresult ;
15111   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15112   Dali::Property::Value *arg2 = 0 ;
15113   Dali::Property::Array *result = 0 ;
15114
15115   arg1 = (Dali::Property::Array *)jarg1;
15116   arg2 = (Dali::Property::Value *)jarg2;
15117   if (!arg2) {
15118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15119     return 0;
15120   }
15121   {
15122     try {
15123       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
15124     } catch (std::out_of_range& e) {
15125       {
15126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15127       };
15128     } catch (std::exception& e) {
15129       {
15130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15131       };
15132     } catch (Dali::DaliException e) {
15133       {
15134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15135       };
15136     } catch (...) {
15137       {
15138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15139       };
15140     }
15141   }
15142
15143   jresult = (void *)result;
15144   return jresult;
15145 }
15146
15147
15148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
15149   void * jresult ;
15150   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15151   Dali::Property::Array::SizeType arg2 ;
15152   Dali::Property::Value *result = 0 ;
15153
15154   arg1 = (Dali::Property::Array *)jarg1;
15155   arg2 = (Dali::Property::Array::SizeType)jarg2;
15156   {
15157     try {
15158       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
15159     } catch (std::out_of_range& e) {
15160       {
15161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15162       };
15163     } catch (std::exception& e) {
15164       {
15165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15166       };
15167     } catch (Dali::DaliException e) {
15168       {
15169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15170       };
15171     } catch (...) {
15172       {
15173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15174       };
15175     }
15176   }
15177
15178   jresult = (void *)result;
15179   return jresult;
15180 }
15181
15182
15183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
15184   void * jresult ;
15185   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15186   Dali::Property::Array::SizeType arg2 ;
15187   Dali::Property::Value *result = 0 ;
15188
15189   arg1 = (Dali::Property::Array *)jarg1;
15190   arg2 = (Dali::Property::Array::SizeType)jarg2;
15191   {
15192     try {
15193       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
15194     } catch (std::out_of_range& e) {
15195       {
15196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15197       };
15198     } catch (std::exception& e) {
15199       {
15200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15201       };
15202     } catch (Dali::DaliException e) {
15203       {
15204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15205       };
15206     } catch (...) {
15207       {
15208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15209       };
15210     }
15211   }
15212
15213   jresult = (void *)result;
15214   return jresult;
15215 }
15216
15217
15218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
15219   void * jresult ;
15220   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15221   Dali::Property::Array *arg2 = 0 ;
15222   Dali::Property::Array *result = 0 ;
15223
15224   arg1 = (Dali::Property::Array *)jarg1;
15225   arg2 = (Dali::Property::Array *)jarg2;
15226   if (!arg2) {
15227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
15228     return 0;
15229   }
15230   {
15231     try {
15232       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
15233     } catch (std::out_of_range& e) {
15234       {
15235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15236       };
15237     } catch (std::exception& e) {
15238       {
15239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15240       };
15241     } catch (Dali::DaliException e) {
15242       {
15243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15244       };
15245     } catch (...) {
15246       {
15247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15248       };
15249     }
15250   }
15251
15252   jresult = (void *)result;
15253   return jresult;
15254 }
15255
15256
15257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
15258   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15259   enum Dali::Property::Key::Type arg2 ;
15260
15261   arg1 = (Dali::Property::Key *)jarg1;
15262   arg2 = (enum Dali::Property::Key::Type)jarg2;
15263   if (arg1) (arg1)->type = arg2;
15264 }
15265
15266
15267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
15268   int jresult ;
15269   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15270   enum Dali::Property::Key::Type result;
15271
15272   arg1 = (Dali::Property::Key *)jarg1;
15273   result = (enum Dali::Property::Key::Type) ((arg1)->type);
15274   jresult = (int)result;
15275   return jresult;
15276 }
15277
15278
15279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
15280   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15281   Dali::Property::Index arg2 ;
15282
15283   arg1 = (Dali::Property::Key *)jarg1;
15284   arg2 = (Dali::Property::Index)jarg2;
15285   if (arg1) (arg1)->indexKey = arg2;
15286 }
15287
15288
15289 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
15290   int jresult ;
15291   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15292   Dali::Property::Index result;
15293
15294   arg1 = (Dali::Property::Key *)jarg1;
15295   result = (Dali::Property::Index) ((arg1)->indexKey);
15296   jresult = result;
15297   return jresult;
15298 }
15299
15300
15301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
15302   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15303   std::string *arg2 = 0 ;
15304
15305   arg1 = (Dali::Property::Key *)jarg1;
15306   if (!jarg2) {
15307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15308     return ;
15309   }
15310   std::string arg2_str(jarg2);
15311   arg2 = &arg2_str;
15312   if (arg1) (arg1)->stringKey = *arg2;
15313
15314   //argout typemap for const std::string&
15315
15316 }
15317
15318
15319 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
15320   char * jresult ;
15321   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15322   std::string *result = 0 ;
15323
15324   arg1 = (Dali::Property::Key *)jarg1;
15325   result = (std::string *) & ((arg1)->stringKey);
15326   jresult = SWIG_csharp_string_callback(result->c_str());
15327   return jresult;
15328 }
15329
15330
15331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
15332   void * jresult ;
15333   std::string *arg1 = 0 ;
15334   Dali::Property::Key *result = 0 ;
15335
15336   if (!jarg1) {
15337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15338     return 0;
15339   }
15340   std::string arg1_str(jarg1);
15341   arg1 = &arg1_str;
15342   {
15343     try {
15344       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
15345     } catch (std::out_of_range& e) {
15346       {
15347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15348       };
15349     } catch (std::exception& e) {
15350       {
15351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15352       };
15353     } catch (Dali::DaliException e) {
15354       {
15355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15356       };
15357     } catch (...) {
15358       {
15359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15360       };
15361     }
15362   }
15363
15364   jresult = (void *)result;
15365
15366   //argout typemap for const std::string&
15367
15368   return jresult;
15369 }
15370
15371
15372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
15373   void * jresult ;
15374   Dali::Property::Index arg1 ;
15375   Dali::Property::Key *result = 0 ;
15376
15377   arg1 = (Dali::Property::Index)jarg1;
15378   {
15379     try {
15380       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
15381     } catch (std::out_of_range& e) {
15382       {
15383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15384       };
15385     } catch (std::exception& e) {
15386       {
15387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15388       };
15389     } catch (Dali::DaliException e) {
15390       {
15391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15392       };
15393     } catch (...) {
15394       {
15395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15396       };
15397     }
15398   }
15399
15400   jresult = (void *)result;
15401   return jresult;
15402 }
15403
15404
15405 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
15406   unsigned int jresult ;
15407   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15408   std::string *arg2 = 0 ;
15409   bool result;
15410
15411   arg1 = (Dali::Property::Key *)jarg1;
15412   if (!jarg2) {
15413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15414     return 0;
15415   }
15416   std::string arg2_str(jarg2);
15417   arg2 = &arg2_str;
15418   {
15419     try {
15420       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
15421     } catch (std::out_of_range& e) {
15422       {
15423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15424       };
15425     } catch (std::exception& e) {
15426       {
15427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15428       };
15429     } catch (Dali::DaliException e) {
15430       {
15431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15432       };
15433     } catch (...) {
15434       {
15435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15436       };
15437     }
15438   }
15439
15440   jresult = result;
15441
15442   //argout typemap for const std::string&
15443
15444   return jresult;
15445 }
15446
15447
15448 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
15449   unsigned int jresult ;
15450   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15451   Dali::Property::Index arg2 ;
15452   bool result;
15453
15454   arg1 = (Dali::Property::Key *)jarg1;
15455   arg2 = (Dali::Property::Index)jarg2;
15456   {
15457     try {
15458       result = (bool)(arg1)->operator ==(arg2);
15459     } catch (std::out_of_range& e) {
15460       {
15461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15462       };
15463     } catch (std::exception& e) {
15464       {
15465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15466       };
15467     } catch (Dali::DaliException e) {
15468       {
15469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15470       };
15471     } catch (...) {
15472       {
15473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15474       };
15475     }
15476   }
15477
15478   jresult = result;
15479   return jresult;
15480 }
15481
15482
15483 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
15484   unsigned int jresult ;
15485   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15486   Dali::Property::Key *arg2 = 0 ;
15487   bool result;
15488
15489   arg1 = (Dali::Property::Key *)jarg1;
15490   arg2 = (Dali::Property::Key *)jarg2;
15491   if (!arg2) {
15492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15493     return 0;
15494   }
15495   {
15496     try {
15497       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
15498     } catch (std::out_of_range& e) {
15499       {
15500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15501       };
15502     } catch (std::exception& e) {
15503       {
15504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15505       };
15506     } catch (Dali::DaliException e) {
15507       {
15508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15509       };
15510     } catch (...) {
15511       {
15512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15513       };
15514     }
15515   }
15516
15517   jresult = result;
15518   return jresult;
15519 }
15520
15521
15522 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
15523   unsigned int jresult ;
15524   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15525   std::string *arg2 = 0 ;
15526   bool result;
15527
15528   arg1 = (Dali::Property::Key *)jarg1;
15529   if (!jarg2) {
15530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15531     return 0;
15532   }
15533   std::string arg2_str(jarg2);
15534   arg2 = &arg2_str;
15535   {
15536     try {
15537       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
15538     } catch (std::out_of_range& e) {
15539       {
15540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15541       };
15542     } catch (std::exception& e) {
15543       {
15544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15545       };
15546     } catch (Dali::DaliException e) {
15547       {
15548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15549       };
15550     } catch (...) {
15551       {
15552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15553       };
15554     }
15555   }
15556
15557   jresult = result;
15558
15559   //argout typemap for const std::string&
15560
15561   return jresult;
15562 }
15563
15564
15565 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
15566   unsigned int jresult ;
15567   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15568   Dali::Property::Index arg2 ;
15569   bool result;
15570
15571   arg1 = (Dali::Property::Key *)jarg1;
15572   arg2 = (Dali::Property::Index)jarg2;
15573   {
15574     try {
15575       result = (bool)(arg1)->operator !=(arg2);
15576     } catch (std::out_of_range& e) {
15577       {
15578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15579       };
15580     } catch (std::exception& e) {
15581       {
15582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15583       };
15584     } catch (Dali::DaliException e) {
15585       {
15586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15587       };
15588     } catch (...) {
15589       {
15590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15591       };
15592     }
15593   }
15594
15595   jresult = result;
15596   return jresult;
15597 }
15598
15599
15600 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
15601   unsigned int jresult ;
15602   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15603   Dali::Property::Key *arg2 = 0 ;
15604   bool result;
15605
15606   arg1 = (Dali::Property::Key *)jarg1;
15607   arg2 = (Dali::Property::Key *)jarg2;
15608   if (!arg2) {
15609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15610     return 0;
15611   }
15612   {
15613     try {
15614       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
15615     } catch (std::out_of_range& e) {
15616       {
15617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15618       };
15619     } catch (std::exception& e) {
15620       {
15621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15622       };
15623     } catch (Dali::DaliException e) {
15624       {
15625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15626       };
15627     } catch (...) {
15628       {
15629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15630       };
15631     }
15632   }
15633
15634   jresult = result;
15635   return jresult;
15636 }
15637
15638
15639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
15640   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15641
15642   arg1 = (Dali::Property::Key *)jarg1;
15643   {
15644     try {
15645       delete arg1;
15646     } catch (std::out_of_range& e) {
15647       {
15648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15649       };
15650     } catch (std::exception& e) {
15651       {
15652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15653       };
15654     } catch (Dali::DaliException e) {
15655       {
15656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15657       };
15658     } catch (...) {
15659       {
15660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15661       };
15662     }
15663   }
15664
15665 }
15666
15667
15668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
15669   void * jresult ;
15670   Dali::Property::Map *result = 0 ;
15671
15672   {
15673     try {
15674       result = (Dali::Property::Map *)new Dali::Property::Map();
15675     } catch (std::out_of_range& e) {
15676       {
15677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15678       };
15679     } catch (std::exception& e) {
15680       {
15681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15682       };
15683     } catch (Dali::DaliException e) {
15684       {
15685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15686       };
15687     } catch (...) {
15688       {
15689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15690       };
15691     }
15692   }
15693
15694   jresult = (void *)result;
15695   return jresult;
15696 }
15697
15698
15699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
15700   void * jresult ;
15701   Dali::Property::Map *arg1 = 0 ;
15702   Dali::Property::Map *result = 0 ;
15703
15704   arg1 = (Dali::Property::Map *)jarg1;
15705   if (!arg1) {
15706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15707     return 0;
15708   }
15709   {
15710     try {
15711       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
15712     } catch (std::out_of_range& e) {
15713       {
15714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15715       };
15716     } catch (std::exception& e) {
15717       {
15718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15719       };
15720     } catch (Dali::DaliException e) {
15721       {
15722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15723       };
15724     } catch (...) {
15725       {
15726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15727       };
15728     }
15729   }
15730
15731   jresult = (void *)result;
15732   return jresult;
15733 }
15734
15735
15736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
15737   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15738
15739   arg1 = (Dali::Property::Map *)jarg1;
15740   {
15741     try {
15742       delete arg1;
15743     } catch (std::out_of_range& e) {
15744       {
15745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15746       };
15747     } catch (std::exception& e) {
15748       {
15749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15750       };
15751     } catch (Dali::DaliException e) {
15752       {
15753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15754       };
15755     } catch (...) {
15756       {
15757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15758       };
15759     }
15760   }
15761
15762 }
15763
15764
15765 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
15766   unsigned long jresult ;
15767   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15768   Dali::Property::Map::SizeType result;
15769
15770   arg1 = (Dali::Property::Map *)jarg1;
15771   {
15772     try {
15773       result = ((Dali::Property::Map const *)arg1)->Count();
15774     } catch (std::out_of_range& e) {
15775       {
15776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15777       };
15778     } catch (std::exception& e) {
15779       {
15780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15781       };
15782     } catch (Dali::DaliException e) {
15783       {
15784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15785       };
15786     } catch (...) {
15787       {
15788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15789       };
15790     }
15791   }
15792
15793   jresult = (unsigned long)result;
15794   return jresult;
15795 }
15796
15797
15798 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
15799   unsigned int jresult ;
15800   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15801   bool result;
15802
15803   arg1 = (Dali::Property::Map *)jarg1;
15804   {
15805     try {
15806       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
15807     } catch (std::out_of_range& e) {
15808       {
15809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15810       };
15811     } catch (std::exception& e) {
15812       {
15813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15814       };
15815     } catch (Dali::DaliException e) {
15816       {
15817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15818       };
15819     } catch (...) {
15820       {
15821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15822       };
15823     }
15824   }
15825
15826   jresult = result;
15827   return jresult;
15828 }
15829
15830
15831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15832   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15833   char *arg2 = (char *) 0 ;
15834   Dali::Property::Value *arg3 = 0 ;
15835
15836   arg1 = (Dali::Property::Map *)jarg1;
15837   arg2 = (char *)jarg2;
15838   arg3 = (Dali::Property::Value *)jarg3;
15839   if (!arg3) {
15840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15841     return ;
15842   }
15843   {
15844     try {
15845       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
15846     } catch (std::out_of_range& e) {
15847       {
15848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15849       };
15850     } catch (std::exception& e) {
15851       {
15852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15853       };
15854     } catch (Dali::DaliException e) {
15855       {
15856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15857       };
15858     } catch (...) {
15859       {
15860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15861       };
15862     }
15863   }
15864
15865 }
15866
15867
15868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
15869   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15870   Dali::Property::Index arg2 ;
15871   Dali::Property::Value *arg3 = 0 ;
15872
15873   arg1 = (Dali::Property::Map *)jarg1;
15874   arg2 = (Dali::Property::Index)jarg2;
15875   arg3 = (Dali::Property::Value *)jarg3;
15876   if (!arg3) {
15877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15878     return ;
15879   }
15880   {
15881     try {
15882       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
15883     } catch (std::out_of_range& e) {
15884       {
15885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15886       };
15887     } catch (std::exception& e) {
15888       {
15889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15890       };
15891     } catch (Dali::DaliException e) {
15892       {
15893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15894       };
15895     } catch (...) {
15896       {
15897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15898       };
15899     }
15900   }
15901
15902 }
15903
15904
15905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15906   void * jresult ;
15907   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15908   char *arg2 = (char *) 0 ;
15909   Dali::Property::Value *arg3 = 0 ;
15910   Dali::Property::Map *result = 0 ;
15911
15912   arg1 = (Dali::Property::Map *)jarg1;
15913   arg2 = (char *)jarg2;
15914   arg3 = (Dali::Property::Value *)jarg3;
15915   if (!arg3) {
15916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15917     return 0;
15918   }
15919   {
15920     try {
15921       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
15922     } catch (std::out_of_range& e) {
15923       {
15924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15925       };
15926     } catch (std::exception& e) {
15927       {
15928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15929       };
15930     } catch (Dali::DaliException e) {
15931       {
15932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15933       };
15934     } catch (...) {
15935       {
15936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15937       };
15938     }
15939   }
15940
15941   jresult = (void *)result;
15942   return jresult;
15943 }
15944
15945
15946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
15947   void * jresult ;
15948   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15949   Dali::Property::Index arg2 ;
15950   Dali::Property::Value *arg3 = 0 ;
15951   Dali::Property::Map *result = 0 ;
15952
15953   arg1 = (Dali::Property::Map *)jarg1;
15954   arg2 = (Dali::Property::Index)jarg2;
15955   arg3 = (Dali::Property::Value *)jarg3;
15956   if (!arg3) {
15957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15958     return 0;
15959   }
15960   {
15961     try {
15962       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
15963     } catch (std::out_of_range& e) {
15964       {
15965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15966       };
15967     } catch (std::exception& e) {
15968       {
15969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15970       };
15971     } catch (Dali::DaliException e) {
15972       {
15973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15974       };
15975     } catch (...) {
15976       {
15977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15978       };
15979     }
15980   }
15981
15982   jresult = (void *)result;
15983   return jresult;
15984 }
15985
15986
15987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
15988   void * jresult ;
15989   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15990   Dali::Property::Map::SizeType arg2 ;
15991   Dali::Property::Value *result = 0 ;
15992
15993   arg1 = (Dali::Property::Map *)jarg1;
15994   arg2 = (Dali::Property::Map::SizeType)jarg2;
15995   {
15996     try {
15997       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
15998     } catch (std::out_of_range& e) {
15999       {
16000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16001       };
16002     } catch (std::exception& e) {
16003       {
16004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16005       };
16006     } catch (Dali::DaliException e) {
16007       {
16008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16009       };
16010     } catch (...) {
16011       {
16012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16013       };
16014     }
16015   }
16016
16017   jresult = (void *)result;
16018   return jresult;
16019 }
16020
16021
16022 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
16023   char * jresult ;
16024   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16025   Dali::Property::Map::SizeType arg2 ;
16026   std::string *result = 0 ;
16027
16028   arg1 = (Dali::Property::Map *)jarg1;
16029   arg2 = (Dali::Property::Map::SizeType)jarg2;
16030   {
16031     try {
16032       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
16033     } catch (std::out_of_range& e) {
16034       {
16035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16036       };
16037     } catch (std::exception& e) {
16038       {
16039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16040       };
16041     } catch (Dali::DaliException e) {
16042       {
16043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16044       };
16045     } catch (...) {
16046       {
16047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16048       };
16049     }
16050   }
16051
16052   jresult = SWIG_csharp_string_callback(result->c_str());
16053   return jresult;
16054 }
16055
16056
16057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
16058   void * jresult ;
16059   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16060   Dali::Property::Map::SizeType arg2 ;
16061   SwigValueWrapper< Dali::Property::Key > result;
16062
16063   arg1 = (Dali::Property::Map *)jarg1;
16064   arg2 = (Dali::Property::Map::SizeType)jarg2;
16065   {
16066     try {
16067       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
16068     } catch (std::out_of_range& e) {
16069       {
16070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16071       };
16072     } catch (std::exception& e) {
16073       {
16074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16075       };
16076     } catch (Dali::DaliException e) {
16077       {
16078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16079       };
16080     } catch (...) {
16081       {
16082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16083       };
16084     }
16085   }
16086
16087   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
16088   return jresult;
16089 }
16090
16091
16092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
16093   void * jresult ;
16094   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16095   Dali::Property::Map::SizeType arg2 ;
16096   StringValuePair *result = 0 ;
16097
16098   arg1 = (Dali::Property::Map *)jarg1;
16099   arg2 = (Dali::Property::Map::SizeType)jarg2;
16100   {
16101     try {
16102       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
16103     } catch (std::out_of_range& e) {
16104       {
16105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16106       };
16107     } catch (std::exception& e) {
16108       {
16109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16110       };
16111     } catch (Dali::DaliException e) {
16112       {
16113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16114       };
16115     } catch (...) {
16116       {
16117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16118       };
16119     }
16120   }
16121
16122   jresult = (void *)result;
16123   return jresult;
16124 }
16125
16126
16127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
16128   void * jresult ;
16129   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16130   char *arg2 = (char *) 0 ;
16131   Dali::Property::Value *result = 0 ;
16132
16133   arg1 = (Dali::Property::Map *)jarg1;
16134   arg2 = (char *)jarg2;
16135   {
16136     try {
16137       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
16138     } catch (std::out_of_range& e) {
16139       {
16140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16141       };
16142     } catch (std::exception& e) {
16143       {
16144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16145       };
16146     } catch (Dali::DaliException e) {
16147       {
16148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16149       };
16150     } catch (...) {
16151       {
16152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16153       };
16154     }
16155   }
16156
16157   jresult = (void *)result;
16158   return jresult;
16159 }
16160
16161
16162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
16163   void * jresult ;
16164   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16165   Dali::Property::Index arg2 ;
16166   Dali::Property::Value *result = 0 ;
16167
16168   arg1 = (Dali::Property::Map *)jarg1;
16169   arg2 = (Dali::Property::Index)jarg2;
16170   {
16171     try {
16172       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
16173     } catch (std::out_of_range& e) {
16174       {
16175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16176       };
16177     } catch (std::exception& e) {
16178       {
16179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16180       };
16181     } catch (Dali::DaliException e) {
16182       {
16183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16184       };
16185     } catch (...) {
16186       {
16187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16188       };
16189     }
16190   }
16191
16192   jresult = (void *)result;
16193   return jresult;
16194 }
16195
16196
16197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
16198   void * jresult ;
16199   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16200   Dali::Property::Index arg2 ;
16201   std::string *arg3 = 0 ;
16202   Dali::Property::Value *result = 0 ;
16203
16204   arg1 = (Dali::Property::Map *)jarg1;
16205   arg2 = (Dali::Property::Index)jarg2;
16206   if (!jarg3) {
16207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16208     return 0;
16209   }
16210   std::string arg3_str(jarg3);
16211   arg3 = &arg3_str;
16212   {
16213     try {
16214       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
16215     } catch (std::out_of_range& e) {
16216       {
16217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16218       };
16219     } catch (std::exception& e) {
16220       {
16221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16222       };
16223     } catch (Dali::DaliException e) {
16224       {
16225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16226       };
16227     } catch (...) {
16228       {
16229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16230       };
16231     }
16232   }
16233
16234   jresult = (void *)result;
16235
16236   //argout typemap for const std::string&
16237
16238   return jresult;
16239 }
16240
16241
16242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
16243   void * jresult ;
16244   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16245   std::string *arg2 = 0 ;
16246   Dali::Property::Type arg3 ;
16247   Dali::Property::Value *result = 0 ;
16248
16249   arg1 = (Dali::Property::Map *)jarg1;
16250   if (!jarg2) {
16251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16252     return 0;
16253   }
16254   std::string arg2_str(jarg2);
16255   arg2 = &arg2_str;
16256   arg3 = (Dali::Property::Type)jarg3;
16257   {
16258     try {
16259       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
16260     } catch (std::out_of_range& e) {
16261       {
16262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16263       };
16264     } catch (std::exception& e) {
16265       {
16266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16267       };
16268     } catch (Dali::DaliException e) {
16269       {
16270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16271       };
16272     } catch (...) {
16273       {
16274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16275       };
16276     }
16277   }
16278
16279   jresult = (void *)result;
16280
16281   //argout typemap for const std::string&
16282
16283   return jresult;
16284 }
16285
16286
16287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
16288   void * jresult ;
16289   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16290   Dali::Property::Index arg2 ;
16291   Dali::Property::Type arg3 ;
16292   Dali::Property::Value *result = 0 ;
16293
16294   arg1 = (Dali::Property::Map *)jarg1;
16295   arg2 = (Dali::Property::Index)jarg2;
16296   arg3 = (Dali::Property::Type)jarg3;
16297   {
16298     try {
16299       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
16300     } catch (std::out_of_range& e) {
16301       {
16302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16303       };
16304     } catch (std::exception& e) {
16305       {
16306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16307       };
16308     } catch (Dali::DaliException e) {
16309       {
16310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16311       };
16312     } catch (...) {
16313       {
16314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16315       };
16316     }
16317   }
16318
16319   jresult = (void *)result;
16320   return jresult;
16321 }
16322
16323
16324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
16325   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16326
16327   arg1 = (Dali::Property::Map *)jarg1;
16328   {
16329     try {
16330       (arg1)->Clear();
16331     } catch (std::out_of_range& e) {
16332       {
16333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16334       };
16335     } catch (std::exception& e) {
16336       {
16337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16338       };
16339     } catch (Dali::DaliException e) {
16340       {
16341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16342       };
16343     } catch (...) {
16344       {
16345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16346       };
16347     }
16348   }
16349
16350 }
16351
16352
16353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
16354   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16355   Dali::Property::Map *arg2 = 0 ;
16356
16357   arg1 = (Dali::Property::Map *)jarg1;
16358   arg2 = (Dali::Property::Map *)jarg2;
16359   if (!arg2) {
16360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16361     return ;
16362   }
16363   {
16364     try {
16365       (arg1)->Merge((Dali::Property::Map const &)*arg2);
16366     } catch (std::out_of_range& e) {
16367       {
16368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16369       };
16370     } catch (std::exception& e) {
16371       {
16372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16373       };
16374     } catch (Dali::DaliException e) {
16375       {
16376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16377       };
16378     } catch (...) {
16379       {
16380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16381       };
16382     }
16383   }
16384
16385 }
16386
16387
16388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
16389   void * jresult ;
16390   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16391   std::string *arg2 = 0 ;
16392   Dali::Property::Value *result = 0 ;
16393
16394   arg1 = (Dali::Property::Map *)jarg1;
16395   if (!jarg2) {
16396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16397     return 0;
16398   }
16399   std::string arg2_str(jarg2);
16400   arg2 = &arg2_str;
16401   {
16402     try {
16403       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
16404     } catch (std::out_of_range& e) {
16405       {
16406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16407       };
16408     } catch (std::exception& e) {
16409       {
16410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16411       };
16412     } catch (Dali::DaliException e) {
16413       {
16414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16415       };
16416     } catch (...) {
16417       {
16418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16419       };
16420     }
16421   }
16422
16423   jresult = (void *)result;
16424
16425   //argout typemap for const std::string&
16426
16427   return jresult;
16428 }
16429
16430
16431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
16432   void * jresult ;
16433   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16434   Dali::Property::Index arg2 ;
16435   Dali::Property::Value *result = 0 ;
16436
16437   arg1 = (Dali::Property::Map *)jarg1;
16438   arg2 = (Dali::Property::Index)jarg2;
16439   {
16440     try {
16441       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
16442     } catch (std::out_of_range& e) {
16443       {
16444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16445       };
16446     } catch (std::exception& e) {
16447       {
16448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16449       };
16450     } catch (Dali::DaliException e) {
16451       {
16452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16453       };
16454     } catch (...) {
16455       {
16456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16457       };
16458     }
16459   }
16460
16461   jresult = (void *)result;
16462   return jresult;
16463 }
16464
16465
16466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
16467   void * jresult ;
16468   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16469   Dali::Property::Map *arg2 = 0 ;
16470   Dali::Property::Map *result = 0 ;
16471
16472   arg1 = (Dali::Property::Map *)jarg1;
16473   arg2 = (Dali::Property::Map *)jarg2;
16474   if (!arg2) {
16475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16476     return 0;
16477   }
16478   {
16479     try {
16480       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
16481     } catch (std::out_of_range& e) {
16482       {
16483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16484       };
16485     } catch (std::exception& e) {
16486       {
16487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16488       };
16489     } catch (Dali::DaliException e) {
16490       {
16491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16492       };
16493     } catch (...) {
16494       {
16495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16496       };
16497     }
16498   }
16499
16500   jresult = (void *)result;
16501   return jresult;
16502 }
16503
16504
16505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
16506   void * jresult ;
16507   Dali::Property::Value *result = 0 ;
16508
16509   {
16510     try {
16511       result = (Dali::Property::Value *)new Dali::Property::Value();
16512     } catch (std::out_of_range& e) {
16513       {
16514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16515       };
16516     } catch (std::exception& e) {
16517       {
16518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16519       };
16520     } catch (Dali::DaliException e) {
16521       {
16522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16523       };
16524     } catch (...) {
16525       {
16526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16527       };
16528     }
16529   }
16530
16531   jresult = (void *)result;
16532   return jresult;
16533 }
16534
16535
16536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
16537   void * jresult ;
16538   bool arg1 ;
16539   Dali::Property::Value *result = 0 ;
16540
16541   arg1 = jarg1 ? true : false;
16542   {
16543     try {
16544       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16545     } catch (std::out_of_range& e) {
16546       {
16547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16548       };
16549     } catch (std::exception& e) {
16550       {
16551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16552       };
16553     } catch (Dali::DaliException e) {
16554       {
16555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16556       };
16557     } catch (...) {
16558       {
16559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16560       };
16561     }
16562   }
16563
16564   jresult = (void *)result;
16565   return jresult;
16566 }
16567
16568
16569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
16570   void * jresult ;
16571   int arg1 ;
16572   Dali::Property::Value *result = 0 ;
16573
16574   arg1 = (int)jarg1;
16575   {
16576     try {
16577       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16578     } catch (std::out_of_range& e) {
16579       {
16580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16581       };
16582     } catch (std::exception& e) {
16583       {
16584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16585       };
16586     } catch (Dali::DaliException e) {
16587       {
16588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16589       };
16590     } catch (...) {
16591       {
16592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16593       };
16594     }
16595   }
16596
16597   jresult = (void *)result;
16598   return jresult;
16599 }
16600
16601
16602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
16603   void * jresult ;
16604   float arg1 ;
16605   Dali::Property::Value *result = 0 ;
16606
16607   arg1 = (float)jarg1;
16608   {
16609     try {
16610       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16611     } catch (std::out_of_range& e) {
16612       {
16613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16614       };
16615     } catch (std::exception& e) {
16616       {
16617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16618       };
16619     } catch (Dali::DaliException e) {
16620       {
16621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16622       };
16623     } catch (...) {
16624       {
16625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16626       };
16627     }
16628   }
16629
16630   jresult = (void *)result;
16631   return jresult;
16632 }
16633
16634
16635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
16636   void * jresult ;
16637   Dali::Vector2 *arg1 = 0 ;
16638   Dali::Property::Value *result = 0 ;
16639
16640   arg1 = (Dali::Vector2 *)jarg1;
16641   if (!arg1) {
16642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
16643     return 0;
16644   }
16645   {
16646     try {
16647       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
16648     } catch (std::out_of_range& e) {
16649       {
16650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16651       };
16652     } catch (std::exception& e) {
16653       {
16654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16655       };
16656     } catch (Dali::DaliException e) {
16657       {
16658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16659       };
16660     } catch (...) {
16661       {
16662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16663       };
16664     }
16665   }
16666
16667   jresult = (void *)result;
16668   return jresult;
16669 }
16670
16671
16672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
16673   void * jresult ;
16674   Dali::Vector3 *arg1 = 0 ;
16675   Dali::Property::Value *result = 0 ;
16676
16677   arg1 = (Dali::Vector3 *)jarg1;
16678   if (!arg1) {
16679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
16680     return 0;
16681   }
16682   {
16683     try {
16684       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
16685     } catch (std::out_of_range& e) {
16686       {
16687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16688       };
16689     } catch (std::exception& e) {
16690       {
16691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16692       };
16693     } catch (Dali::DaliException e) {
16694       {
16695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16696       };
16697     } catch (...) {
16698       {
16699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16700       };
16701     }
16702   }
16703
16704   jresult = (void *)result;
16705   return jresult;
16706 }
16707
16708
16709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
16710   void * jresult ;
16711   Dali::Vector4 *arg1 = 0 ;
16712   Dali::Property::Value *result = 0 ;
16713
16714   arg1 = (Dali::Vector4 *)jarg1;
16715   if (!arg1) {
16716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
16717     return 0;
16718   }
16719   {
16720     try {
16721       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
16722     } catch (std::out_of_range& e) {
16723       {
16724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16725       };
16726     } catch (std::exception& e) {
16727       {
16728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16729       };
16730     } catch (Dali::DaliException e) {
16731       {
16732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16733       };
16734     } catch (...) {
16735       {
16736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16737       };
16738     }
16739   }
16740
16741   jresult = (void *)result;
16742   return jresult;
16743 }
16744
16745
16746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
16747   void * jresult ;
16748   Dali::Matrix3 *arg1 = 0 ;
16749   Dali::Property::Value *result = 0 ;
16750
16751   arg1 = (Dali::Matrix3 *)jarg1;
16752   if (!arg1) {
16753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
16754     return 0;
16755   }
16756   {
16757     try {
16758       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
16759     } catch (std::out_of_range& e) {
16760       {
16761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16762       };
16763     } catch (std::exception& e) {
16764       {
16765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16766       };
16767     } catch (Dali::DaliException e) {
16768       {
16769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16770       };
16771     } catch (...) {
16772       {
16773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16774       };
16775     }
16776   }
16777
16778   jresult = (void *)result;
16779   return jresult;
16780 }
16781
16782
16783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
16784   void * jresult ;
16785   Dali::Matrix *arg1 = 0 ;
16786   Dali::Property::Value *result = 0 ;
16787
16788   arg1 = (Dali::Matrix *)jarg1;
16789   if (!arg1) {
16790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
16791     return 0;
16792   }
16793   {
16794     try {
16795       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
16796     } catch (std::out_of_range& e) {
16797       {
16798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16799       };
16800     } catch (std::exception& e) {
16801       {
16802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16803       };
16804     } catch (Dali::DaliException e) {
16805       {
16806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16807       };
16808     } catch (...) {
16809       {
16810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16811       };
16812     }
16813   }
16814
16815   jresult = (void *)result;
16816   return jresult;
16817 }
16818
16819
16820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
16821   void * jresult ;
16822   Dali::Rect< int > *arg1 = 0 ;
16823   Dali::Property::Value *result = 0 ;
16824
16825   arg1 = (Dali::Rect< int > *)jarg1;
16826   if (!arg1) {
16827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
16828     return 0;
16829   }
16830   {
16831     try {
16832       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
16833     } catch (std::out_of_range& e) {
16834       {
16835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16836       };
16837     } catch (std::exception& e) {
16838       {
16839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16840       };
16841     } catch (Dali::DaliException e) {
16842       {
16843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16844       };
16845     } catch (...) {
16846       {
16847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16848       };
16849     }
16850   }
16851
16852   jresult = (void *)result;
16853   return jresult;
16854 }
16855
16856
16857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
16858   void * jresult ;
16859   Dali::AngleAxis *arg1 = 0 ;
16860   Dali::Property::Value *result = 0 ;
16861
16862   arg1 = (Dali::AngleAxis *)jarg1;
16863   if (!arg1) {
16864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
16865     return 0;
16866   }
16867   {
16868     try {
16869       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
16870     } catch (std::out_of_range& e) {
16871       {
16872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16873       };
16874     } catch (std::exception& e) {
16875       {
16876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16877       };
16878     } catch (Dali::DaliException e) {
16879       {
16880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16881       };
16882     } catch (...) {
16883       {
16884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16885       };
16886     }
16887   }
16888
16889   jresult = (void *)result;
16890   return jresult;
16891 }
16892
16893
16894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
16895   void * jresult ;
16896   Dali::Quaternion *arg1 = 0 ;
16897   Dali::Property::Value *result = 0 ;
16898
16899   arg1 = (Dali::Quaternion *)jarg1;
16900   if (!arg1) {
16901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
16902     return 0;
16903   }
16904   {
16905     try {
16906       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
16907     } catch (std::out_of_range& e) {
16908       {
16909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16910       };
16911     } catch (std::exception& e) {
16912       {
16913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16914       };
16915     } catch (Dali::DaliException e) {
16916       {
16917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16918       };
16919     } catch (...) {
16920       {
16921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16922       };
16923     }
16924   }
16925
16926   jresult = (void *)result;
16927   return jresult;
16928 }
16929
16930
16931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
16932   void * jresult ;
16933   std::string *arg1 = 0 ;
16934   Dali::Property::Value *result = 0 ;
16935
16936   if (!jarg1) {
16937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16938     return 0;
16939   }
16940   std::string arg1_str(jarg1);
16941   arg1 = &arg1_str;
16942   {
16943     try {
16944       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
16945     } catch (std::out_of_range& e) {
16946       {
16947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16948       };
16949     } catch (std::exception& e) {
16950       {
16951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16952       };
16953     } catch (Dali::DaliException e) {
16954       {
16955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16956       };
16957     } catch (...) {
16958       {
16959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16960       };
16961     }
16962   }
16963
16964   jresult = (void *)result;
16965
16966   //argout typemap for const std::string&
16967
16968   return jresult;
16969 }
16970
16971
16972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
16973   void * jresult ;
16974   Dali::Property::Array *arg1 = 0 ;
16975   Dali::Property::Value *result = 0 ;
16976
16977   arg1 = (Dali::Property::Array *)jarg1;
16978   if (!arg1) {
16979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
16980     return 0;
16981   }
16982   {
16983     try {
16984       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
16985     } catch (std::out_of_range& e) {
16986       {
16987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16988       };
16989     } catch (std::exception& e) {
16990       {
16991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16992       };
16993     } catch (Dali::DaliException e) {
16994       {
16995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16996       };
16997     } catch (...) {
16998       {
16999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17000       };
17001     }
17002   }
17003
17004   jresult = (void *)result;
17005   return jresult;
17006 }
17007
17008
17009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
17010   void * jresult ;
17011   Dali::Property::Map *arg1 = 0 ;
17012   Dali::Property::Value *result = 0 ;
17013
17014   arg1 = (Dali::Property::Map *)jarg1;
17015   if (!arg1) {
17016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17017     return 0;
17018   }
17019   {
17020     try {
17021       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17022     } catch (std::out_of_range& e) {
17023       {
17024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17025       };
17026     } catch (std::exception& e) {
17027       {
17028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17029       };
17030     } catch (Dali::DaliException e) {
17031       {
17032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17033       };
17034     } catch (...) {
17035       {
17036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17037       };
17038     }
17039   }
17040
17041   jresult = (void *)result;
17042   return jresult;
17043 }
17044
17045
17046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
17047   void * jresult ;
17048   Extents *arg1 = 0 ;
17049   Dali::Property::Value *result = 0 ;
17050
17051   arg1 = (Extents *)jarg1;
17052   if (!arg1) {
17053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
17054     return 0;
17055   }
17056   {
17057     try {
17058       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
17059     } catch (std::out_of_range& e) {
17060       {
17061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17062       };
17063     } catch (std::exception& e) {
17064       {
17065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17066       };
17067     } catch (...) {
17068       {
17069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17070       };
17071     }
17072   }
17073   jresult = (void *)result;
17074   return jresult;
17075 }
17076
17077
17078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
17079   void * jresult ;
17080   Dali::Property::Type arg1 ;
17081   Dali::Property::Value *result = 0 ;
17082
17083   arg1 = (Dali::Property::Type)jarg1;
17084   {
17085     try {
17086       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
17087     } catch (std::out_of_range& e) {
17088       {
17089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17090       };
17091     } catch (std::exception& e) {
17092       {
17093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17094       };
17095     } catch (Dali::DaliException e) {
17096       {
17097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17098       };
17099     } catch (...) {
17100       {
17101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17102       };
17103     }
17104   }
17105
17106   jresult = (void *)result;
17107   return jresult;
17108 }
17109
17110
17111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
17112   void * jresult ;
17113   Dali::Property::Value *arg1 = 0 ;
17114   Dali::Property::Value *result = 0 ;
17115
17116   arg1 = (Dali::Property::Value *)jarg1;
17117   if (!arg1) {
17118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17119     return 0;
17120   }
17121   {
17122     try {
17123       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*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_Property_Value_Assign(void * jarg1, void * jarg2) {
17149   void * jresult ;
17150   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17151   Dali::Property::Value *arg2 = 0 ;
17152   Dali::Property::Value *result = 0 ;
17153
17154   arg1 = (Dali::Property::Value *)jarg1;
17155   arg2 = (Dali::Property::Value *)jarg2;
17156   if (!arg2) {
17157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17158     return 0;
17159   }
17160   {
17161     try {
17162       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
17163     } catch (std::out_of_range& e) {
17164       {
17165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17166       };
17167     } catch (std::exception& e) {
17168       {
17169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17170       };
17171     } catch (Dali::DaliException e) {
17172       {
17173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17174       };
17175     } catch (...) {
17176       {
17177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17178       };
17179     }
17180   }
17181
17182   jresult = (void *)result;
17183   return jresult;
17184 }
17185
17186
17187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
17188   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17189
17190   arg1 = (Dali::Property::Value *)jarg1;
17191   {
17192     try {
17193       delete arg1;
17194     } catch (std::out_of_range& e) {
17195       {
17196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17197       };
17198     } catch (std::exception& e) {
17199       {
17200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17201       };
17202     } catch (Dali::DaliException e) {
17203       {
17204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
17205       };
17206     } catch (...) {
17207       {
17208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17209       };
17210     }
17211   }
17212
17213 }
17214
17215
17216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
17217   int jresult ;
17218   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17219   Dali::Property::Type result;
17220
17221   arg1 = (Dali::Property::Value *)jarg1;
17222   {
17223     try {
17224       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
17225     } catch (std::out_of_range& e) {
17226       {
17227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17228       };
17229     } catch (std::exception& e) {
17230       {
17231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17232       };
17233     } catch (Dali::DaliException e) {
17234       {
17235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17236       };
17237     } catch (...) {
17238       {
17239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17240       };
17241     }
17242   }
17243
17244   jresult = (int)result;
17245   return jresult;
17246 }
17247
17248
17249 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
17250   unsigned int jresult ;
17251   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17252   bool *arg2 = 0 ;
17253   bool result;
17254
17255   arg1 = (Dali::Property::Value *)jarg1;
17256   arg2 = (bool *)jarg2;
17257   {
17258     try {
17259       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17260     } catch (std::out_of_range& e) {
17261       {
17262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17263       };
17264     } catch (std::exception& e) {
17265       {
17266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17267       };
17268     } catch (Dali::DaliException e) {
17269       {
17270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17271       };
17272     } catch (...) {
17273       {
17274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17275       };
17276     }
17277   }
17278
17279   jresult = result;
17280   return jresult;
17281 }
17282
17283
17284 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
17285   unsigned int jresult ;
17286   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17287   float *arg2 = 0 ;
17288   bool result;
17289
17290   arg1 = (Dali::Property::Value *)jarg1;
17291   arg2 = (float *)jarg2;
17292   {
17293     try {
17294       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17295     } catch (std::out_of_range& e) {
17296       {
17297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17298       };
17299     } catch (std::exception& e) {
17300       {
17301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17302       };
17303     } catch (Dali::DaliException e) {
17304       {
17305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17306       };
17307     } catch (...) {
17308       {
17309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17310       };
17311     }
17312   }
17313
17314   jresult = result;
17315   return jresult;
17316 }
17317
17318
17319 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
17320   unsigned int jresult ;
17321   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17322   int *arg2 = 0 ;
17323   bool result;
17324
17325   arg1 = (Dali::Property::Value *)jarg1;
17326   arg2 = (int *)jarg2;
17327   {
17328     try {
17329       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17330     } catch (std::out_of_range& e) {
17331       {
17332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17333       };
17334     } catch (std::exception& e) {
17335       {
17336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17337       };
17338     } catch (Dali::DaliException e) {
17339       {
17340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17341       };
17342     } catch (...) {
17343       {
17344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17345       };
17346     }
17347   }
17348
17349   jresult = result;
17350   return jresult;
17351 }
17352
17353
17354 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
17355   unsigned int jresult ;
17356   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17357   Dali::Rect< int > *arg2 = 0 ;
17358   bool result;
17359
17360   arg1 = (Dali::Property::Value *)jarg1;
17361   arg2 = (Dali::Rect< int > *)jarg2;
17362   if (!arg2) {
17363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
17364     return 0;
17365   }
17366   {
17367     try {
17368       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17369     } catch (std::out_of_range& e) {
17370       {
17371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17372       };
17373     } catch (std::exception& e) {
17374       {
17375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17376       };
17377     } catch (Dali::DaliException e) {
17378       {
17379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17380       };
17381     } catch (...) {
17382       {
17383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17384       };
17385     }
17386   }
17387
17388   jresult = result;
17389   return jresult;
17390 }
17391
17392
17393 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
17394   unsigned int jresult ;
17395   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17396   Dali::Vector2 *arg2 = 0 ;
17397   bool result;
17398
17399   arg1 = (Dali::Property::Value *)jarg1;
17400   arg2 = (Dali::Vector2 *)jarg2;
17401   if (!arg2) {
17402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
17403     return 0;
17404   }
17405   {
17406     try {
17407       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17408     } catch (std::out_of_range& e) {
17409       {
17410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17411       };
17412     } catch (std::exception& e) {
17413       {
17414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17415       };
17416     } catch (Dali::DaliException e) {
17417       {
17418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17419       };
17420     } catch (...) {
17421       {
17422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17423       };
17424     }
17425   }
17426
17427   jresult = result;
17428   return jresult;
17429 }
17430
17431
17432 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
17433   unsigned int jresult ;
17434   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17435   Dali::Vector3 *arg2 = 0 ;
17436   bool result;
17437
17438   arg1 = (Dali::Property::Value *)jarg1;
17439   arg2 = (Dali::Vector3 *)jarg2;
17440   if (!arg2) {
17441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
17442     return 0;
17443   }
17444   {
17445     try {
17446       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17447     } catch (std::out_of_range& e) {
17448       {
17449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17450       };
17451     } catch (std::exception& e) {
17452       {
17453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17454       };
17455     } catch (Dali::DaliException e) {
17456       {
17457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17458       };
17459     } catch (...) {
17460       {
17461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17462       };
17463     }
17464   }
17465
17466   jresult = result;
17467   return jresult;
17468 }
17469
17470
17471 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
17472   unsigned int jresult ;
17473   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17474   Dali::Vector4 *arg2 = 0 ;
17475   bool result;
17476
17477   arg1 = (Dali::Property::Value *)jarg1;
17478   arg2 = (Dali::Vector4 *)jarg2;
17479   if (!arg2) {
17480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
17481     return 0;
17482   }
17483   {
17484     try {
17485       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17486     } catch (std::out_of_range& e) {
17487       {
17488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17489       };
17490     } catch (std::exception& e) {
17491       {
17492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17493       };
17494     } catch (Dali::DaliException e) {
17495       {
17496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17497       };
17498     } catch (...) {
17499       {
17500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17501       };
17502     }
17503   }
17504
17505   jresult = result;
17506   return jresult;
17507 }
17508
17509
17510 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
17511   unsigned int jresult ;
17512   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17513   Dali::Matrix3 *arg2 = 0 ;
17514   bool result;
17515
17516   arg1 = (Dali::Property::Value *)jarg1;
17517   arg2 = (Dali::Matrix3 *)jarg2;
17518   if (!arg2) {
17519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
17520     return 0;
17521   }
17522   {
17523     try {
17524       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17525     } catch (std::out_of_range& e) {
17526       {
17527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17528       };
17529     } catch (std::exception& e) {
17530       {
17531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17532       };
17533     } catch (Dali::DaliException e) {
17534       {
17535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17536       };
17537     } catch (...) {
17538       {
17539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17540       };
17541     }
17542   }
17543
17544   jresult = result;
17545   return jresult;
17546 }
17547
17548
17549 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
17550   unsigned int jresult ;
17551   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17552   Dali::Matrix *arg2 = 0 ;
17553   bool result;
17554
17555   arg1 = (Dali::Property::Value *)jarg1;
17556   arg2 = (Dali::Matrix *)jarg2;
17557   if (!arg2) {
17558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
17559     return 0;
17560   }
17561   {
17562     try {
17563       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17564     } catch (std::out_of_range& e) {
17565       {
17566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17567       };
17568     } catch (std::exception& e) {
17569       {
17570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17571       };
17572     } catch (Dali::DaliException e) {
17573       {
17574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17575       };
17576     } catch (...) {
17577       {
17578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17579       };
17580     }
17581   }
17582
17583   jresult = result;
17584   return jresult;
17585 }
17586
17587
17588 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
17589   unsigned int jresult ;
17590   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17591   Dali::AngleAxis *arg2 = 0 ;
17592   bool result;
17593
17594   arg1 = (Dali::Property::Value *)jarg1;
17595   arg2 = (Dali::AngleAxis *)jarg2;
17596   if (!arg2) {
17597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
17598     return 0;
17599   }
17600   {
17601     try {
17602       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17603     } catch (std::out_of_range& e) {
17604       {
17605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17606       };
17607     } catch (std::exception& e) {
17608       {
17609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17610       };
17611     } catch (Dali::DaliException e) {
17612       {
17613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17614       };
17615     } catch (...) {
17616       {
17617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17618       };
17619     }
17620   }
17621
17622   jresult = result;
17623   return jresult;
17624 }
17625
17626
17627 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
17628   unsigned int jresult ;
17629   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17630   Dali::Quaternion *arg2 = 0 ;
17631   bool result;
17632
17633   arg1 = (Dali::Property::Value *)jarg1;
17634   arg2 = (Dali::Quaternion *)jarg2;
17635   if (!arg2) {
17636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
17637     return 0;
17638   }
17639   {
17640     try {
17641       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17642     } catch (std::out_of_range& e) {
17643       {
17644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17645       };
17646     } catch (std::exception& e) {
17647       {
17648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17649       };
17650     } catch (Dali::DaliException e) {
17651       {
17652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17653       };
17654     } catch (...) {
17655       {
17656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17657       };
17658     }
17659   }
17660
17661   jresult = result;
17662   return jresult;
17663 }
17664
17665
17666 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
17667   unsigned int jresult ;
17668   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17669   std::string *arg2 = 0 ;
17670   bool result;
17671
17672   arg1 = (Dali::Property::Value *)jarg1;
17673
17674   //typemap in
17675   std::string temp;
17676   arg2 = &temp;
17677
17678   {
17679     try {
17680       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17681     } catch (std::out_of_range& e) {
17682       {
17683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17684       };
17685     } catch (std::exception& e) {
17686       {
17687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17688       };
17689     } catch (Dali::DaliException e) {
17690       {
17691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17692       };
17693     } catch (...) {
17694       {
17695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17696       };
17697     }
17698   }
17699
17700   jresult = result;
17701
17702   //Typemap argout in c++ file.
17703   //This will convert c++ string to c# string
17704   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
17705
17706   return jresult;
17707 }
17708
17709
17710 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
17711   unsigned int jresult ;
17712   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17713   Dali::Property::Array *arg2 = 0 ;
17714   bool result;
17715
17716   arg1 = (Dali::Property::Value *)jarg1;
17717   arg2 = (Dali::Property::Array *)jarg2;
17718   if (!arg2) {
17719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17720     return 0;
17721   }
17722   {
17723     try {
17724       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17725     } catch (std::out_of_range& e) {
17726       {
17727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17728       };
17729     } catch (std::exception& e) {
17730       {
17731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17732       };
17733     } catch (Dali::DaliException e) {
17734       {
17735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17736       };
17737     } catch (...) {
17738       {
17739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17740       };
17741     }
17742   }
17743
17744   jresult = result;
17745   return jresult;
17746 }
17747
17748
17749 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
17750   unsigned int jresult ;
17751   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17752   Dali::Property::Map *arg2 = 0 ;
17753   bool result;
17754
17755   arg1 = (Dali::Property::Value *)jarg1;
17756   arg2 = (Dali::Property::Map *)jarg2;
17757   if (!arg2) {
17758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17759     return 0;
17760   }
17761   {
17762     try {
17763       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17764     } catch (std::out_of_range& e) {
17765       {
17766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17767       };
17768     } catch (std::exception& e) {
17769       {
17770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17771       };
17772     } catch (Dali::DaliException e) {
17773       {
17774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17775       };
17776     } catch (...) {
17777       {
17778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17779       };
17780     }
17781   }
17782
17783   jresult = result;
17784   return jresult;
17785 }
17786
17787
17788 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
17789   unsigned int jresult ;
17790   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17791   Extents *arg2 = 0 ;
17792   bool result;
17793
17794   arg1 = (Dali::Property::Value *)jarg1;
17795   arg2 = (Extents *)jarg2;
17796   if (!arg2) {
17797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
17798     return 0;
17799   }
17800   {
17801     try {
17802       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17803     } catch (std::out_of_range& e) {
17804       {
17805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17806       };
17807     } catch (std::exception& e) {
17808       {
17809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17810       };
17811     } catch (...) {
17812       {
17813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17814       };
17815     }
17816   }
17817   jresult = result;
17818   return jresult;
17819 }
17820
17821
17822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
17823   void * jresult ;
17824   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17825   Dali::Property::Array *result = 0 ;
17826
17827   arg1 = (Dali::Property::Value *)jarg1;
17828   {
17829     try {
17830       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
17831     } catch (std::out_of_range& e) {
17832       {
17833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17834       };
17835     } catch (std::exception& e) {
17836       {
17837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17838       };
17839     } catch (Dali::DaliException e) {
17840       {
17841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17842       };
17843     } catch (...) {
17844       {
17845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17846       };
17847     }
17848   }
17849
17850   jresult = (void *)result;
17851   return jresult;
17852 }
17853
17854
17855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
17856   void * jresult ;
17857   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17858   Dali::Property::Map *result = 0 ;
17859
17860   arg1 = (Dali::Property::Value *)jarg1;
17861   {
17862     try {
17863       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
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 = (void *)result;
17884   return jresult;
17885 }
17886
17887
17888 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
17889   char * jresult ;
17890   Dali::Property::Type arg1 ;
17891   char *result = 0 ;
17892
17893   arg1 = (Dali::Property::Type)jarg1;
17894   {
17895     try {
17896       result = (char *)Dali::PropertyTypes::GetName(arg1);
17897     } catch (std::out_of_range& e) {
17898       {
17899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17900       };
17901     } catch (std::exception& e) {
17902       {
17903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17904       };
17905     } catch (Dali::DaliException e) {
17906       {
17907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17908       };
17909     } catch (...) {
17910       {
17911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17912       };
17913     }
17914   }
17915
17916   jresult = SWIG_csharp_string_callback((const char *)result);
17917   return jresult;
17918 }
17919
17920
17921 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
17922   unsigned int jresult ;
17923   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
17924   std::string *arg2 = 0 ;
17925   Dali::Property::Map *arg3 = 0 ;
17926   bool result;
17927
17928   arg1 = (Dali::BaseObject *)jarg1;
17929   if (!jarg2) {
17930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17931     return 0;
17932   }
17933   std::string arg2_str(jarg2);
17934   arg2 = &arg2_str;
17935   arg3 = (Dali::Property::Map *)jarg3;
17936   if (!arg3) {
17937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
17938     return 0;
17939   }
17940   {
17941     try {
17942       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
17943     } catch (std::out_of_range& e) {
17944       {
17945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17946       };
17947     } catch (std::exception& e) {
17948       {
17949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17950       };
17951     } catch (Dali::DaliException e) {
17952       {
17953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17954       };
17955     } catch (...) {
17956       {
17957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17958       };
17959     }
17960   }
17961
17962   jresult = result;
17963
17964   //argout typemap for const std::string&
17965
17966   return jresult;
17967 }
17968
17969
17970 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
17971   char * jresult ;
17972   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
17973   std::string *result = 0 ;
17974
17975   arg1 = (Dali::BaseObject *)jarg1;
17976   {
17977     try {
17978       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
17979     } catch (std::out_of_range& e) {
17980       {
17981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17982       };
17983     } catch (std::exception& e) {
17984       {
17985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17986       };
17987     } catch (Dali::DaliException e) {
17988       {
17989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17990       };
17991     } catch (...) {
17992       {
17993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17994       };
17995     }
17996   }
17997
17998   jresult = SWIG_csharp_string_callback(result->c_str());
17999   return jresult;
18000 }
18001
18002
18003 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
18004   unsigned int jresult ;
18005   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18006   Dali::TypeInfo *arg2 = 0 ;
18007   bool result;
18008
18009   arg1 = (Dali::BaseObject *)jarg1;
18010   arg2 = (Dali::TypeInfo *)jarg2;
18011   if (!arg2) {
18012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18013     return 0;
18014   }
18015   {
18016     try {
18017       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
18018     } catch (std::out_of_range& e) {
18019       {
18020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18021       };
18022     } catch (std::exception& e) {
18023       {
18024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18025       };
18026     } catch (Dali::DaliException e) {
18027       {
18028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18029       };
18030     } catch (...) {
18031       {
18032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18033       };
18034     }
18035   }
18036
18037   jresult = result;
18038   return jresult;
18039 }
18040
18041
18042 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
18043   unsigned int jresult ;
18044   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18045   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
18046   std::string *arg3 = 0 ;
18047   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
18048   bool result;
18049
18050   arg1 = (Dali::BaseObject *)jarg1;
18051   arg2 = (ConnectionTrackerInterface *)jarg2;
18052   if (!jarg3) {
18053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18054     return 0;
18055   }
18056   std::string arg3_str(jarg3);
18057   arg3 = &arg3_str;
18058   arg4 = (FunctorDelegate *)jarg4;
18059   {
18060     try {
18061       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
18062     } catch (std::out_of_range& e) {
18063       {
18064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18065       };
18066     } catch (std::exception& e) {
18067       {
18068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18069       };
18070     } catch (Dali::DaliException e) {
18071       {
18072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18073       };
18074     } catch (...) {
18075       {
18076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18077       };
18078     }
18079   }
18080
18081   jresult = result;
18082
18083   //argout typemap for const std::string&
18084
18085   return jresult;
18086 }
18087
18088
18089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
18090   void * jresult ;
18091   Dali::BaseHandle *arg1 = 0 ;
18092   Dali::BaseObject *result = 0 ;
18093
18094   arg1 = (Dali::BaseHandle *)jarg1;
18095   if (!arg1) {
18096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18097     return 0;
18098   }
18099   {
18100     try {
18101       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
18102     } catch (std::out_of_range& e) {
18103       {
18104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18105       };
18106     } catch (std::exception& e) {
18107       {
18108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18109       };
18110     } catch (Dali::DaliException e) {
18111       {
18112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18113       };
18114     } catch (...) {
18115       {
18116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18117       };
18118     }
18119   }
18120
18121   jresult = (void *)result;
18122   return jresult;
18123 }
18124
18125
18126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
18127   void * jresult ;
18128   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18129   Dali::BaseHandle *result = 0 ;
18130
18131   arg1 = (Dali::BaseObject *)jarg1;
18132   {
18133     try {
18134       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
18135     } catch (std::out_of_range& e) {
18136       {
18137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18138       };
18139     } catch (std::exception& e) {
18140       {
18141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18142       };
18143     } catch (Dali::DaliException e) {
18144       {
18145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18146       };
18147     } catch (...) {
18148       {
18149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18150       };
18151     }
18152   }
18153
18154   jresult = (void *)result;
18155   return jresult;
18156 }
18157
18158
18159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
18160   void * jresult ;
18161   Dali::BaseHandle *result = 0 ;
18162
18163   {
18164     try {
18165       result = (Dali::BaseHandle *)new Dali::BaseHandle();
18166     } catch (std::out_of_range& e) {
18167       {
18168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18169       };
18170     } catch (std::exception& e) {
18171       {
18172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18173       };
18174     } catch (Dali::DaliException e) {
18175       {
18176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18177       };
18178     } catch (...) {
18179       {
18180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18181       };
18182     }
18183   }
18184
18185   jresult = (void *)result;
18186   return jresult;
18187 }
18188
18189
18190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
18191   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18192
18193   arg1 = (Dali::BaseHandle *)jarg1;
18194   {
18195     try {
18196       delete arg1;
18197     } catch (std::out_of_range& e) {
18198       {
18199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18200       };
18201     } catch (std::exception& e) {
18202       {
18203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18204       };
18205     } catch (Dali::DaliException e) {
18206       {
18207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18208       };
18209     } catch (...) {
18210       {
18211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18212       };
18213     }
18214   }
18215
18216 }
18217
18218
18219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
18220   void * jresult ;
18221   Dali::BaseHandle *arg1 = 0 ;
18222   Dali::BaseHandle *result = 0 ;
18223
18224   arg1 = (Dali::BaseHandle *)jarg1;
18225   if (!arg1) {
18226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18227     return 0;
18228   }
18229   {
18230     try {
18231       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
18232     } catch (std::out_of_range& e) {
18233       {
18234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18235       };
18236     } catch (std::exception& e) {
18237       {
18238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18239       };
18240     } catch (Dali::DaliException e) {
18241       {
18242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18243       };
18244     } catch (...) {
18245       {
18246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18247       };
18248     }
18249   }
18250
18251   jresult = (void *)result;
18252   return jresult;
18253 }
18254
18255
18256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
18257   void * jresult ;
18258   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18259   Dali::BaseHandle *arg2 = 0 ;
18260   Dali::BaseHandle *result = 0 ;
18261
18262   arg1 = (Dali::BaseHandle *)jarg1;
18263   arg2 = (Dali::BaseHandle *)jarg2;
18264   if (!arg2) {
18265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18266     return 0;
18267   }
18268   {
18269     try {
18270       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
18271     } catch (std::out_of_range& e) {
18272       {
18273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18274       };
18275     } catch (std::exception& e) {
18276       {
18277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18278       };
18279     } catch (Dali::DaliException e) {
18280       {
18281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18282       };
18283     } catch (...) {
18284       {
18285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18286       };
18287     }
18288   }
18289
18290   jresult = (void *)result;
18291   return jresult;
18292 }
18293
18294
18295 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18296   unsigned int jresult ;
18297   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18298   std::string *arg2 = 0 ;
18299   Dali::Property::Map *arg3 = 0 ;
18300   bool result;
18301
18302   arg1 = (Dali::BaseHandle *)jarg1;
18303   if (!jarg2) {
18304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18305     return 0;
18306   }
18307   std::string arg2_str(jarg2);
18308   arg2 = &arg2_str;
18309   arg3 = (Dali::Property::Map *)jarg3;
18310   if (!arg3) {
18311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18312     return 0;
18313   }
18314   {
18315     try {
18316       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18317     } catch (std::out_of_range& e) {
18318       {
18319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18320       };
18321     } catch (std::exception& e) {
18322       {
18323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18324       };
18325     } catch (Dali::DaliException e) {
18326       {
18327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18328       };
18329     } catch (...) {
18330       {
18331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18332       };
18333     }
18334   }
18335
18336   jresult = result;
18337
18338   //argout typemap for const std::string&
18339
18340   return jresult;
18341 }
18342
18343
18344 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
18345   char * jresult ;
18346   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18347   std::string *result = 0 ;
18348
18349   arg1 = (Dali::BaseHandle *)jarg1;
18350   {
18351     try {
18352       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
18353     } catch (std::out_of_range& e) {
18354       {
18355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18356       };
18357     } catch (std::exception& e) {
18358       {
18359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18360       };
18361     } catch (Dali::DaliException e) {
18362       {
18363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18364       };
18365     } catch (...) {
18366       {
18367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18368       };
18369     }
18370   }
18371
18372   jresult = SWIG_csharp_string_callback(result->c_str());
18373   return jresult;
18374 }
18375
18376
18377 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
18378   unsigned int jresult ;
18379   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18380   Dali::TypeInfo *arg2 = 0 ;
18381   bool result;
18382
18383   arg1 = (Dali::BaseHandle *)jarg1;
18384   arg2 = (Dali::TypeInfo *)jarg2;
18385   if (!arg2) {
18386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18387     return 0;
18388   }
18389   {
18390     try {
18391       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
18392     } catch (std::out_of_range& e) {
18393       {
18394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18395       };
18396     } catch (std::exception& e) {
18397       {
18398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18399       };
18400     } catch (Dali::DaliException e) {
18401       {
18402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18403       };
18404     } catch (...) {
18405       {
18406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18407       };
18408     }
18409   }
18410
18411   jresult = result;
18412   return jresult;
18413 }
18414
18415
18416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
18417   void * jresult ;
18418   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18419   Dali::BaseObject *result = 0 ;
18420
18421   arg1 = (Dali::BaseHandle *)jarg1;
18422   {
18423     try {
18424       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
18425     } catch (std::out_of_range& e) {
18426       {
18427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18428       };
18429     } catch (std::exception& e) {
18430       {
18431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18432       };
18433     } catch (Dali::DaliException e) {
18434       {
18435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18436       };
18437     } catch (...) {
18438       {
18439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18440       };
18441     }
18442   }
18443
18444   jresult = (void *)result;
18445   return jresult;
18446 }
18447
18448
18449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
18450   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18451
18452   arg1 = (Dali::BaseHandle *)jarg1;
18453   {
18454     try {
18455       (arg1)->Reset();
18456     } catch (std::out_of_range& e) {
18457       {
18458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18459       };
18460     } catch (std::exception& e) {
18461       {
18462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18463       };
18464     } catch (Dali::DaliException e) {
18465       {
18466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18467       };
18468     } catch (...) {
18469       {
18470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18471       };
18472     }
18473   }
18474
18475 }
18476
18477
18478 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
18479   unsigned int jresult ;
18480   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18481   Dali::BaseHandle *arg2 = 0 ;
18482   bool result;
18483
18484   arg1 = (Dali::BaseHandle *)jarg1;
18485   arg2 = (Dali::BaseHandle *)jarg2;
18486   if (!arg2) {
18487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18488     return 0;
18489   }
18490   {
18491     try {
18492       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
18493     } catch (std::out_of_range& e) {
18494       {
18495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18496       };
18497     } catch (std::exception& e) {
18498       {
18499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18500       };
18501     } catch (Dali::DaliException e) {
18502       {
18503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18504       };
18505     } catch (...) {
18506       {
18507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18508       };
18509     }
18510   }
18511
18512   jresult = result;
18513   return jresult;
18514 }
18515
18516
18517 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
18518   unsigned int jresult ;
18519   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18520   Dali::BaseHandle *arg2 = 0 ;
18521   bool result;
18522
18523   arg1 = (Dali::BaseHandle *)jarg1;
18524   arg2 = (Dali::BaseHandle *)jarg2;
18525   if (!arg2) {
18526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18527     return 0;
18528   }
18529   {
18530     try {
18531       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
18532     } catch (std::out_of_range& e) {
18533       {
18534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18535       };
18536     } catch (std::exception& e) {
18537       {
18538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18539       };
18540     } catch (Dali::DaliException e) {
18541       {
18542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18543       };
18544     } catch (...) {
18545       {
18546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18547       };
18548     }
18549   }
18550
18551   jresult = result;
18552   return jresult;
18553 }
18554
18555
18556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
18557   void * jresult ;
18558   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18559   Dali::RefObject *result = 0 ;
18560
18561   arg1 = (Dali::BaseHandle *)jarg1;
18562   {
18563     try {
18564       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
18565     } catch (std::out_of_range& e) {
18566       {
18567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18568       };
18569     } catch (std::exception& e) {
18570       {
18571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18572       };
18573     } catch (Dali::DaliException e) {
18574       {
18575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18576       };
18577     } catch (...) {
18578       {
18579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18580       };
18581     }
18582   }
18583
18584   jresult = (void *)result;
18585   return jresult;
18586 }
18587
18588
18589 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
18590   unsigned int jresult ;
18591   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18592   bool result;
18593
18594   arg1 = (Dali::BaseHandle *)jarg1;
18595   {
18596     try {
18597       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
18598     } catch (std::out_of_range& e) {
18599       {
18600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18601       };
18602     } catch (std::exception& e) {
18603       {
18604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18605       };
18606     } catch (Dali::DaliException e) {
18607       {
18608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18609       };
18610     } catch (...) {
18611       {
18612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18613       };
18614     }
18615   }
18616
18617   jresult = result;
18618   return jresult;
18619 }
18620
18621
18622 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
18623   unsigned int jresult ;
18624   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18625   Dali::BaseHandle *arg2 = 0 ;
18626   bool result;
18627
18628   arg1 = (Dali::BaseHandle *)jarg1;
18629   arg2 = (Dali::BaseHandle *)jarg2;
18630   if (!arg2) {
18631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18632     return 0;
18633   }
18634   {
18635     try {
18636       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
18637     } catch (std::out_of_range& e) {
18638       {
18639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18640       };
18641     } catch (std::exception& e) {
18642       {
18643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18644       };
18645     } catch (Dali::DaliException e) {
18646       {
18647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18648       };
18649     } catch (...) {
18650       {
18651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18652       };
18653     }
18654   }
18655
18656   jresult = result;
18657   return jresult;
18658 }
18659
18660
18661 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
18662   unsigned int jresult ;
18663   Dali::BaseHandle *arg1 = 0 ;
18664   Dali::BaseHandle *arg2 = 0 ;
18665   bool result;
18666
18667   arg1 = (Dali::BaseHandle *)jarg1;
18668   if (!arg1) {
18669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18670     return 0;
18671   }
18672   arg2 = (Dali::BaseHandle *)jarg2;
18673   if (!arg2) {
18674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18675     return 0;
18676   }
18677   {
18678     try {
18679       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
18680     } catch (std::out_of_range& e) {
18681       {
18682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18683       };
18684     } catch (std::exception& e) {
18685       {
18686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18687       };
18688     } catch (Dali::DaliException e) {
18689       {
18690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18691       };
18692     } catch (...) {
18693       {
18694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18695       };
18696     }
18697   }
18698
18699   jresult = result;
18700   return jresult;
18701 }
18702
18703
18704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
18705   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18706
18707   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18708   {
18709     try {
18710       delete arg1;
18711     } catch (std::out_of_range& e) {
18712       {
18713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18714       };
18715     } catch (std::exception& e) {
18716       {
18717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18718       };
18719     } catch (Dali::DaliException e) {
18720       {
18721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18722       };
18723     } catch (...) {
18724       {
18725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18726       };
18727     }
18728   }
18729
18730 }
18731
18732
18733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
18734   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18735   SlotObserver *arg2 = (SlotObserver *) 0 ;
18736   CallbackBase *arg3 = (CallbackBase *) 0 ;
18737
18738   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18739   arg2 = (SlotObserver *)jarg2;
18740   arg3 = (CallbackBase *)jarg3;
18741   {
18742     try {
18743       (arg1)->SignalConnected(arg2,arg3);
18744     } catch (std::out_of_range& e) {
18745       {
18746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18747       };
18748     } catch (std::exception& e) {
18749       {
18750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18751       };
18752     } catch (Dali::DaliException e) {
18753       {
18754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18755       };
18756     } catch (...) {
18757       {
18758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18759       };
18760     }
18761   }
18762
18763 }
18764
18765
18766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
18767   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18768
18769   arg1 = (Dali::SignalObserver *)jarg1;
18770   {
18771     try {
18772       delete arg1;
18773     } catch (std::out_of_range& e) {
18774       {
18775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18776       };
18777     } catch (std::exception& e) {
18778       {
18779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18780       };
18781     } catch (Dali::DaliException e) {
18782       {
18783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18784       };
18785     } catch (...) {
18786       {
18787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18788       };
18789     }
18790   }
18791
18792 }
18793
18794
18795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
18796   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18797   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
18798   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
18799
18800   arg1 = (Dali::SignalObserver *)jarg1;
18801   arg2 = (Dali::SlotObserver *)jarg2;
18802   arg3 = (Dali::CallbackBase *)jarg3;
18803   {
18804     try {
18805       (arg1)->SignalDisconnected(arg2,arg3);
18806     } catch (std::out_of_range& e) {
18807       {
18808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18809       };
18810     } catch (std::exception& e) {
18811       {
18812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18813       };
18814     } catch (Dali::DaliException e) {
18815       {
18816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18817       };
18818     } catch (...) {
18819       {
18820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18821       };
18822     }
18823   }
18824
18825 }
18826
18827
18828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
18829   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18830
18831   arg1 = (Dali::SlotObserver *)jarg1;
18832   {
18833     try {
18834       delete arg1;
18835     } catch (std::out_of_range& e) {
18836       {
18837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18838       };
18839     } catch (std::exception& e) {
18840       {
18841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18842       };
18843     } catch (Dali::DaliException e) {
18844       {
18845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18846       };
18847     } catch (...) {
18848       {
18849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18850       };
18851     }
18852   }
18853
18854 }
18855
18856
18857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
18858   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18859   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
18860
18861   arg1 = (Dali::SlotObserver *)jarg1;
18862   arg2 = (Dali::CallbackBase *)jarg2;
18863   {
18864     try {
18865       (arg1)->SlotDisconnected(arg2);
18866     } catch (std::out_of_range& e) {
18867       {
18868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18869       };
18870     } catch (std::exception& e) {
18871       {
18872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18873       };
18874     } catch (Dali::DaliException e) {
18875       {
18876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18877       };
18878     } catch (...) {
18879       {
18880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18881       };
18882     }
18883   }
18884
18885 }
18886
18887
18888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
18889   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
18890
18891   arg1 = (Dali::ConnectionTracker *)jarg1;
18892   {
18893     try {
18894       delete arg1;
18895     } catch (std::out_of_range& e) {
18896       {
18897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18898       };
18899     } catch (std::exception& e) {
18900       {
18901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18902       };
18903     } catch (Dali::DaliException e) {
18904       {
18905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18906       };
18907     } catch (...) {
18908       {
18909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18910       };
18911     }
18912   }
18913
18914 }
18915
18916
18917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
18918   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
18919
18920   arg1 = (Dali::ConnectionTracker *)jarg1;
18921   {
18922     try {
18923       (arg1)->DisconnectAll();
18924     } catch (std::out_of_range& e) {
18925       {
18926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18927       };
18928     } catch (std::exception& e) {
18929       {
18930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18931       };
18932     } catch (Dali::DaliException e) {
18933       {
18934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18935       };
18936     } catch (...) {
18937       {
18938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18939       };
18940     }
18941   }
18942
18943 }
18944
18945
18946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
18947   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
18948   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
18949   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
18950
18951   arg1 = (Dali::ConnectionTracker *)jarg1;
18952   arg2 = (Dali::SlotObserver *)jarg2;
18953   arg3 = (Dali::CallbackBase *)jarg3;
18954   {
18955     try {
18956       (arg1)->SignalConnected(arg2,arg3);
18957     } catch (std::out_of_range& e) {
18958       {
18959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18960       };
18961     } catch (std::exception& e) {
18962       {
18963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18964       };
18965     } catch (Dali::DaliException e) {
18966       {
18967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18968       };
18969     } catch (...) {
18970       {
18971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18972       };
18973     }
18974   }
18975
18976 }
18977
18978
18979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
18980   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
18981   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
18982   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
18983
18984   arg1 = (Dali::ConnectionTracker *)jarg1;
18985   arg2 = (Dali::SlotObserver *)jarg2;
18986   arg3 = (Dali::CallbackBase *)jarg3;
18987   {
18988     try {
18989       (arg1)->SignalDisconnected(arg2,arg3);
18990     } catch (std::out_of_range& e) {
18991       {
18992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18993       };
18994     } catch (std::exception& e) {
18995       {
18996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18997       };
18998     } catch (Dali::DaliException e) {
18999       {
19000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19001       };
19002     } catch (...) {
19003       {
19004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19005       };
19006     }
19007   }
19008
19009 }
19010
19011
19012 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
19013   unsigned long jresult ;
19014   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19015   std::size_t result;
19016
19017   arg1 = (Dali::ConnectionTracker *)jarg1;
19018   {
19019     try {
19020       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
19021     } catch (std::out_of_range& e) {
19022       {
19023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19024       };
19025     } catch (std::exception& e) {
19026       {
19027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19028       };
19029     } catch (Dali::DaliException e) {
19030       {
19031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19032       };
19033     } catch (...) {
19034       {
19035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19036       };
19037     }
19038   }
19039
19040   jresult = (unsigned long)result;
19041   return jresult;
19042 }
19043
19044
19045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
19046   void * jresult ;
19047   Dali::ObjectRegistry *result = 0 ;
19048
19049   {
19050     try {
19051       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
19052     } catch (std::out_of_range& e) {
19053       {
19054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19055       };
19056     } catch (std::exception& e) {
19057       {
19058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19059       };
19060     } catch (Dali::DaliException e) {
19061       {
19062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19063       };
19064     } catch (...) {
19065       {
19066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19067       };
19068     }
19069   }
19070
19071   jresult = (void *)result;
19072   return jresult;
19073 }
19074
19075
19076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
19077   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19078
19079   arg1 = (Dali::ObjectRegistry *)jarg1;
19080   {
19081     try {
19082       delete arg1;
19083     } catch (std::out_of_range& e) {
19084       {
19085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19086       };
19087     } catch (std::exception& e) {
19088       {
19089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19090       };
19091     } catch (Dali::DaliException e) {
19092       {
19093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19094       };
19095     } catch (...) {
19096       {
19097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19098       };
19099     }
19100   }
19101
19102 }
19103
19104
19105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
19106   void * jresult ;
19107   Dali::ObjectRegistry *arg1 = 0 ;
19108   Dali::ObjectRegistry *result = 0 ;
19109
19110   arg1 = (Dali::ObjectRegistry *)jarg1;
19111   if (!arg1) {
19112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19113     return 0;
19114   }
19115   {
19116     try {
19117       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
19118     } catch (std::out_of_range& e) {
19119       {
19120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19121       };
19122     } catch (std::exception& e) {
19123       {
19124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19125       };
19126     } catch (Dali::DaliException e) {
19127       {
19128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19129       };
19130     } catch (...) {
19131       {
19132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19133       };
19134     }
19135   }
19136
19137   jresult = (void *)result;
19138   return jresult;
19139 }
19140
19141
19142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
19143   void * jresult ;
19144   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19145   Dali::ObjectRegistry *arg2 = 0 ;
19146   Dali::ObjectRegistry *result = 0 ;
19147
19148   arg1 = (Dali::ObjectRegistry *)jarg1;
19149   arg2 = (Dali::ObjectRegistry *)jarg2;
19150   if (!arg2) {
19151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19152     return 0;
19153   }
19154   {
19155     try {
19156       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
19157     } catch (std::out_of_range& e) {
19158       {
19159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19160       };
19161     } catch (std::exception& e) {
19162       {
19163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19164       };
19165     } catch (Dali::DaliException e) {
19166       {
19167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19168       };
19169     } catch (...) {
19170       {
19171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19172       };
19173     }
19174   }
19175
19176   jresult = (void *)result;
19177   return jresult;
19178 }
19179
19180
19181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
19182   void * jresult ;
19183   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19184   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
19185
19186   arg1 = (Dali::ObjectRegistry *)jarg1;
19187   {
19188     try {
19189       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
19190     } catch (std::out_of_range& e) {
19191       {
19192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19193       };
19194     } catch (std::exception& e) {
19195       {
19196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19197       };
19198     } catch (Dali::DaliException e) {
19199       {
19200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19201       };
19202     } catch (...) {
19203       {
19204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19205       };
19206     }
19207   }
19208
19209   jresult = (void *)result;
19210   return jresult;
19211 }
19212
19213
19214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
19215   void * jresult ;
19216   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19217   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
19218
19219   arg1 = (Dali::ObjectRegistry *)jarg1;
19220   {
19221     try {
19222       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
19223     } catch (std::out_of_range& e) {
19224       {
19225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19226       };
19227     } catch (std::exception& e) {
19228       {
19229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19230       };
19231     } catch (Dali::DaliException e) {
19232       {
19233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19234       };
19235     } catch (...) {
19236       {
19237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19238       };
19239     }
19240   }
19241
19242   jresult = (void *)result;
19243   return jresult;
19244 }
19245
19246
19247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
19248   void * jresult ;
19249   Dali::PropertyCondition *result = 0 ;
19250
19251   {
19252     try {
19253       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
19254     } catch (std::out_of_range& e) {
19255       {
19256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19257       };
19258     } catch (std::exception& e) {
19259       {
19260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19261       };
19262     } catch (Dali::DaliException e) {
19263       {
19264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19265       };
19266     } catch (...) {
19267       {
19268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19269       };
19270     }
19271   }
19272
19273   jresult = (void *)result;
19274   return jresult;
19275 }
19276
19277
19278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
19279   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19280
19281   arg1 = (Dali::PropertyCondition *)jarg1;
19282   {
19283     try {
19284       delete arg1;
19285     } catch (std::out_of_range& e) {
19286       {
19287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19288       };
19289     } catch (std::exception& e) {
19290       {
19291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19292       };
19293     } catch (Dali::DaliException e) {
19294       {
19295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19296       };
19297     } catch (...) {
19298       {
19299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19300       };
19301     }
19302   }
19303
19304 }
19305
19306
19307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
19308   void * jresult ;
19309   Dali::PropertyCondition *arg1 = 0 ;
19310   Dali::PropertyCondition *result = 0 ;
19311
19312   arg1 = (Dali::PropertyCondition *)jarg1;
19313   if (!arg1) {
19314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19315     return 0;
19316   }
19317   {
19318     try {
19319       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
19320     } catch (std::out_of_range& e) {
19321       {
19322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19323       };
19324     } catch (std::exception& e) {
19325       {
19326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19327       };
19328     } catch (Dali::DaliException e) {
19329       {
19330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19331       };
19332     } catch (...) {
19333       {
19334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19335       };
19336     }
19337   }
19338
19339   jresult = (void *)result;
19340   return jresult;
19341 }
19342
19343
19344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
19345   void * jresult ;
19346   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19347   Dali::PropertyCondition *arg2 = 0 ;
19348   Dali::PropertyCondition *result = 0 ;
19349
19350   arg1 = (Dali::PropertyCondition *)jarg1;
19351   arg2 = (Dali::PropertyCondition *)jarg2;
19352   if (!arg2) {
19353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19354     return 0;
19355   }
19356   {
19357     try {
19358       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
19359     } catch (std::out_of_range& e) {
19360       {
19361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19362       };
19363     } catch (std::exception& e) {
19364       {
19365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19366       };
19367     } catch (Dali::DaliException e) {
19368       {
19369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19370       };
19371     } catch (...) {
19372       {
19373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19374       };
19375     }
19376   }
19377
19378   jresult = (void *)result;
19379   return jresult;
19380 }
19381
19382
19383 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
19384   unsigned long jresult ;
19385   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19386   std::size_t result;
19387
19388   arg1 = (Dali::PropertyCondition *)jarg1;
19389   {
19390     try {
19391       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
19392     } catch (std::out_of_range& e) {
19393       {
19394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19395       };
19396     } catch (std::exception& e) {
19397       {
19398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19399       };
19400     } catch (...) {
19401       {
19402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19403       };
19404     }
19405   }
19406   jresult = (unsigned long)result;
19407   return jresult;
19408 }
19409
19410
19411 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
19412   float jresult ;
19413   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19414   std::size_t arg2 ;
19415   float result;
19416
19417   arg1 = (Dali::PropertyCondition *)jarg1;
19418   arg2 = (std::size_t)jarg2;
19419   {
19420     try {
19421       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
19422     } catch (std::out_of_range& e) {
19423       {
19424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19425       };
19426     } catch (std::exception& e) {
19427       {
19428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19429       };
19430     } catch (...) {
19431       {
19432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19433       };
19434     }
19435   }
19436   jresult = result;
19437   return jresult;
19438 }
19439
19440
19441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
19442   void * jresult ;
19443   float arg1 ;
19444   Dali::PropertyCondition result;
19445
19446   arg1 = (float)jarg1;
19447   {
19448     try {
19449       result = Dali::LessThanCondition(arg1);
19450     } catch (std::out_of_range& e) {
19451       {
19452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19453       };
19454     } catch (std::exception& e) {
19455       {
19456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19457       };
19458     } catch (Dali::DaliException e) {
19459       {
19460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19461       };
19462     } catch (...) {
19463       {
19464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19465       };
19466     }
19467   }
19468
19469   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19470   return jresult;
19471 }
19472
19473
19474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
19475   void * jresult ;
19476   float arg1 ;
19477   Dali::PropertyCondition result;
19478
19479   arg1 = (float)jarg1;
19480   {
19481     try {
19482       result = Dali::GreaterThanCondition(arg1);
19483     } catch (std::out_of_range& e) {
19484       {
19485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19486       };
19487     } catch (std::exception& e) {
19488       {
19489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19490       };
19491     } catch (Dali::DaliException e) {
19492       {
19493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19494       };
19495     } catch (...) {
19496       {
19497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19498       };
19499     }
19500   }
19501
19502   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19503   return jresult;
19504 }
19505
19506
19507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
19508   void * jresult ;
19509   float arg1 ;
19510   float arg2 ;
19511   Dali::PropertyCondition result;
19512
19513   arg1 = (float)jarg1;
19514   arg2 = (float)jarg2;
19515   {
19516     try {
19517       result = Dali::InsideCondition(arg1,arg2);
19518     } catch (std::out_of_range& e) {
19519       {
19520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19521       };
19522     } catch (std::exception& e) {
19523       {
19524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19525       };
19526     } catch (Dali::DaliException e) {
19527       {
19528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19529       };
19530     } catch (...) {
19531       {
19532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19533       };
19534     }
19535   }
19536
19537   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19538   return jresult;
19539 }
19540
19541
19542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
19543   void * jresult ;
19544   float arg1 ;
19545   float arg2 ;
19546   Dali::PropertyCondition result;
19547
19548   arg1 = (float)jarg1;
19549   arg2 = (float)jarg2;
19550   {
19551     try {
19552       result = Dali::OutsideCondition(arg1,arg2);
19553     } catch (std::out_of_range& e) {
19554       {
19555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19556       };
19557     } catch (std::exception& e) {
19558       {
19559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19560       };
19561     } catch (Dali::DaliException e) {
19562       {
19563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19564       };
19565     } catch (...) {
19566       {
19567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19568       };
19569     }
19570   }
19571
19572   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19573   return jresult;
19574 }
19575
19576
19577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
19578   void * jresult ;
19579   float arg1 ;
19580   float arg2 ;
19581   Dali::PropertyCondition result;
19582
19583   arg1 = (float)jarg1;
19584   arg2 = (float)jarg2;
19585   {
19586     try {
19587       result = Dali::StepCondition(arg1,arg2);
19588     } catch (std::out_of_range& e) {
19589       {
19590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19591       };
19592     } catch (std::exception& e) {
19593       {
19594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19595       };
19596     } catch (Dali::DaliException e) {
19597       {
19598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19599       };
19600     } catch (...) {
19601       {
19602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19603       };
19604     }
19605   }
19606
19607   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19608   return jresult;
19609 }
19610
19611
19612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
19613   void * jresult ;
19614   float arg1 ;
19615   Dali::PropertyCondition result;
19616
19617   arg1 = (float)jarg1;
19618   {
19619     try {
19620       result = Dali::StepCondition(arg1);
19621     } catch (std::out_of_range& e) {
19622       {
19623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19624       };
19625     } catch (std::exception& e) {
19626       {
19627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19628       };
19629     } catch (Dali::DaliException e) {
19630       {
19631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19632       };
19633     } catch (...) {
19634       {
19635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19636       };
19637     }
19638   }
19639
19640   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19641   return jresult;
19642 }
19643
19644
19645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
19646   void * jresult ;
19647   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
19648   Dali::PropertyCondition result;
19649
19650   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
19651   if (!arg1) {
19652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
19653     return 0;
19654   }
19655   {
19656     try {
19657       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
19658     } catch (std::out_of_range& e) {
19659       {
19660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19661       };
19662     } catch (std::exception& e) {
19663       {
19664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19665       };
19666     } catch (Dali::DaliException e) {
19667       {
19668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19669       };
19670     } catch (...) {
19671       {
19672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19673       };
19674     }
19675   }
19676
19677   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19678   return jresult;
19679 }
19680
19681
19682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
19683   void * jresult ;
19684   Dali::PropertyNotification *result = 0 ;
19685
19686   {
19687     try {
19688       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
19689     } catch (std::out_of_range& e) {
19690       {
19691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19692       };
19693     } catch (std::exception& e) {
19694       {
19695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19696       };
19697     } catch (Dali::DaliException e) {
19698       {
19699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19700       };
19701     } catch (...) {
19702       {
19703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19704       };
19705     }
19706   }
19707
19708   jresult = (void *)result;
19709   return jresult;
19710 }
19711
19712
19713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
19714   void * jresult ;
19715   Dali::BaseHandle arg1 ;
19716   Dali::BaseHandle *argp1 ;
19717   Dali::PropertyNotification result;
19718
19719   argp1 = (Dali::BaseHandle *)jarg1;
19720   if (!argp1) {
19721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19722     return 0;
19723   }
19724   arg1 = *argp1;
19725   {
19726     try {
19727       result = Dali::PropertyNotification::DownCast(arg1);
19728     } catch (std::out_of_range& e) {
19729       {
19730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19731       };
19732     } catch (std::exception& e) {
19733       {
19734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19735       };
19736     } catch (Dali::DaliException e) {
19737       {
19738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19739       };
19740     } catch (...) {
19741       {
19742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19743       };
19744     }
19745   }
19746
19747   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
19748   return jresult;
19749 }
19750
19751
19752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
19753   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19754
19755   arg1 = (Dali::PropertyNotification *)jarg1;
19756   {
19757     try {
19758       delete arg1;
19759     } catch (std::out_of_range& e) {
19760       {
19761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19762       };
19763     } catch (std::exception& e) {
19764       {
19765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19766       };
19767     } catch (Dali::DaliException e) {
19768       {
19769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19770       };
19771     } catch (...) {
19772       {
19773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19774       };
19775     }
19776   }
19777
19778 }
19779
19780
19781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
19782   void * jresult ;
19783   Dali::PropertyNotification *arg1 = 0 ;
19784   Dali::PropertyNotification *result = 0 ;
19785
19786   arg1 = (Dali::PropertyNotification *)jarg1;
19787   if (!arg1) {
19788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19789     return 0;
19790   }
19791   {
19792     try {
19793       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
19794     } catch (std::out_of_range& e) {
19795       {
19796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19797       };
19798     } catch (std::exception& e) {
19799       {
19800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19801       };
19802     } catch (Dali::DaliException e) {
19803       {
19804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19805       };
19806     } catch (...) {
19807       {
19808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19809       };
19810     }
19811   }
19812
19813   jresult = (void *)result;
19814   return jresult;
19815 }
19816
19817
19818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
19819   void * jresult ;
19820   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19821   Dali::PropertyNotification *arg2 = 0 ;
19822   Dali::PropertyNotification *result = 0 ;
19823
19824   arg1 = (Dali::PropertyNotification *)jarg1;
19825   arg2 = (Dali::PropertyNotification *)jarg2;
19826   if (!arg2) {
19827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19828     return 0;
19829   }
19830   {
19831     try {
19832       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
19833     } catch (std::out_of_range& e) {
19834       {
19835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19836       };
19837     } catch (std::exception& e) {
19838       {
19839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19840       };
19841     } catch (Dali::DaliException e) {
19842       {
19843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19844       };
19845     } catch (...) {
19846       {
19847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19848       };
19849     }
19850   }
19851
19852   jresult = (void *)result;
19853   return jresult;
19854 }
19855
19856
19857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
19858   void * jresult ;
19859   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19860   Dali::PropertyCondition result;
19861
19862   arg1 = (Dali::PropertyNotification *)jarg1;
19863   {
19864     try {
19865       result = (arg1)->GetCondition();
19866     } catch (std::out_of_range& e) {
19867       {
19868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19869       };
19870     } catch (std::exception& e) {
19871       {
19872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19873       };
19874     } catch (Dali::DaliException e) {
19875       {
19876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19877       };
19878     } catch (...) {
19879       {
19880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19881       };
19882     }
19883   }
19884
19885   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19886   return jresult;
19887 }
19888
19889
19890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
19891   void * jresult ;
19892   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19893   Dali::Handle result;
19894
19895   arg1 = (Dali::PropertyNotification *)jarg1;
19896   {
19897     try {
19898       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
19899     } catch (std::out_of_range& e) {
19900       {
19901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19902       };
19903     } catch (std::exception& e) {
19904       {
19905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19906       };
19907     } catch (Dali::DaliException e) {
19908       {
19909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19910       };
19911     } catch (...) {
19912       {
19913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19914       };
19915     }
19916   }
19917
19918   jresult = new Dali::Handle((const Dali::Handle &)result);
19919   return jresult;
19920 }
19921
19922
19923 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
19924   int jresult ;
19925   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19926   Dali::Property::Index result;
19927
19928   arg1 = (Dali::PropertyNotification *)jarg1;
19929   {
19930     try {
19931       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
19932     } catch (std::out_of_range& e) {
19933       {
19934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19935       };
19936     } catch (std::exception& e) {
19937       {
19938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19939       };
19940     } catch (Dali::DaliException e) {
19941       {
19942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19943       };
19944     } catch (...) {
19945       {
19946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19947       };
19948     }
19949   }
19950
19951   jresult = result;
19952   return jresult;
19953 }
19954
19955
19956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
19957   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19958   Dali::PropertyNotification::NotifyMode arg2 ;
19959
19960   arg1 = (Dali::PropertyNotification *)jarg1;
19961   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
19962   {
19963     try {
19964       (arg1)->SetNotifyMode(arg2);
19965     } catch (std::out_of_range& e) {
19966       {
19967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19968       };
19969     } catch (std::exception& e) {
19970       {
19971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19972       };
19973     } catch (Dali::DaliException e) {
19974       {
19975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19976       };
19977     } catch (...) {
19978       {
19979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19980       };
19981     }
19982   }
19983
19984 }
19985
19986
19987 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
19988   int jresult ;
19989   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19990   Dali::PropertyNotification::NotifyMode result;
19991
19992   arg1 = (Dali::PropertyNotification *)jarg1;
19993   {
19994     try {
19995       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
19996     } catch (std::out_of_range& e) {
19997       {
19998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19999       };
20000     } catch (std::exception& e) {
20001       {
20002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20003       };
20004     } catch (Dali::DaliException e) {
20005       {
20006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20007       };
20008     } catch (...) {
20009       {
20010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20011       };
20012     }
20013   }
20014
20015   jresult = (int)result;
20016   return jresult;
20017 }
20018
20019
20020 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
20021   unsigned int jresult ;
20022   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20023   bool result;
20024
20025   arg1 = (Dali::PropertyNotification *)jarg1;
20026   {
20027     try {
20028       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
20029     } catch (std::out_of_range& e) {
20030       {
20031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20032       };
20033     } catch (std::exception& e) {
20034       {
20035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20036       };
20037     } catch (Dali::DaliException e) {
20038       {
20039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20040       };
20041     } catch (...) {
20042       {
20043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20044       };
20045     }
20046   }
20047
20048   jresult = result;
20049   return jresult;
20050 }
20051
20052
20053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
20054   void * jresult ;
20055   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20056   Dali::PropertyNotifySignalType *result = 0 ;
20057
20058   arg1 = (Dali::PropertyNotification *)jarg1;
20059   {
20060     try {
20061       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
20062     } catch (std::out_of_range& e) {
20063       {
20064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20065       };
20066     } catch (std::exception& e) {
20067       {
20068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20069       };
20070     } catch (Dali::DaliException e) {
20071       {
20072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20073       };
20074     } catch (...) {
20075       {
20076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20077       };
20078     }
20079   }
20080
20081   jresult = (void *)result;
20082   return jresult;
20083 }
20084
20085
20086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
20087   void * jresult ;
20088   Dali::Handle *result = 0 ;
20089
20090   {
20091     try {
20092       result = (Dali::Handle *)new Dali::Handle();
20093     } catch (std::out_of_range& e) {
20094       {
20095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20096       };
20097     } catch (std::exception& e) {
20098       {
20099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20100       };
20101     } catch (Dali::DaliException e) {
20102       {
20103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20104       };
20105     } catch (...) {
20106       {
20107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20108       };
20109     }
20110   }
20111
20112   jresult = (void *)result;
20113   return jresult;
20114 }
20115
20116
20117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
20118   void * jresult ;
20119   Dali::Handle result;
20120
20121   {
20122     try {
20123       result = Dali::Handle::New();
20124     } catch (std::out_of_range& e) {
20125       {
20126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20127       };
20128     } catch (std::exception& e) {
20129       {
20130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20131       };
20132     } catch (Dali::DaliException e) {
20133       {
20134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20135       };
20136     } catch (...) {
20137       {
20138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20139       };
20140     }
20141   }
20142
20143   jresult = new Dali::Handle((const Dali::Handle &)result);
20144   return jresult;
20145 }
20146
20147
20148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
20149   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20150
20151   arg1 = (Dali::Handle *)jarg1;
20152   {
20153     try {
20154       delete arg1;
20155     } catch (std::out_of_range& e) {
20156       {
20157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20158       };
20159     } catch (std::exception& e) {
20160       {
20161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20162       };
20163     } catch (Dali::DaliException e) {
20164       {
20165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20166       };
20167     } catch (...) {
20168       {
20169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20170       };
20171     }
20172   }
20173
20174 }
20175
20176
20177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
20178   void * jresult ;
20179   Dali::Handle *arg1 = 0 ;
20180   Dali::Handle *result = 0 ;
20181
20182   arg1 = (Dali::Handle *)jarg1;
20183   if (!arg1) {
20184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20185     return 0;
20186   }
20187   {
20188     try {
20189       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
20190     } catch (std::out_of_range& e) {
20191       {
20192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20193       };
20194     } catch (std::exception& e) {
20195       {
20196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20197       };
20198     } catch (Dali::DaliException e) {
20199       {
20200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20201       };
20202     } catch (...) {
20203       {
20204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20205       };
20206     }
20207   }
20208
20209   jresult = (void *)result;
20210   return jresult;
20211 }
20212
20213
20214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
20215   void * jresult ;
20216   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20217   Dali::Handle *arg2 = 0 ;
20218   Dali::Handle *result = 0 ;
20219
20220   arg1 = (Dali::Handle *)jarg1;
20221   arg2 = (Dali::Handle *)jarg2;
20222   if (!arg2) {
20223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20224     return 0;
20225   }
20226   {
20227     try {
20228       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
20229     } catch (std::out_of_range& e) {
20230       {
20231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20232       };
20233     } catch (std::exception& e) {
20234       {
20235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20236       };
20237     } catch (Dali::DaliException e) {
20238       {
20239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20240       };
20241     } catch (...) {
20242       {
20243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20244       };
20245     }
20246   }
20247
20248   jresult = (void *)result;
20249   return jresult;
20250 }
20251
20252
20253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
20254   void * jresult ;
20255   Dali::BaseHandle arg1 ;
20256   Dali::BaseHandle *argp1 ;
20257   Dali::Handle result;
20258
20259   argp1 = (Dali::BaseHandle *)jarg1;
20260   if (!argp1) {
20261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20262     return 0;
20263   }
20264   arg1 = *argp1;
20265   {
20266     try {
20267       result = Dali::Handle::DownCast(arg1);
20268     } catch (std::out_of_range& e) {
20269       {
20270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20271       };
20272     } catch (std::exception& e) {
20273       {
20274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20275       };
20276     } catch (Dali::DaliException e) {
20277       {
20278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20279       };
20280     } catch (...) {
20281       {
20282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20283       };
20284     }
20285   }
20286
20287   jresult = new Dali::Handle((const Dali::Handle &)result);
20288   return jresult;
20289 }
20290
20291
20292 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
20293   unsigned int jresult ;
20294   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20295   Dali::Handle::Capability arg2 ;
20296   bool result;
20297
20298   arg1 = (Dali::Handle *)jarg1;
20299   arg2 = (Dali::Handle::Capability)jarg2;
20300   {
20301     try {
20302       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
20303     } catch (std::out_of_range& e) {
20304       {
20305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20306       };
20307     } catch (std::exception& e) {
20308       {
20309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20310       };
20311     } catch (Dali::DaliException e) {
20312       {
20313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20314       };
20315     } catch (...) {
20316       {
20317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20318       };
20319     }
20320   }
20321
20322   jresult = result;
20323   return jresult;
20324 }
20325
20326
20327 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
20328   unsigned int jresult ;
20329   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20330   unsigned int result;
20331
20332   arg1 = (Dali::Handle *)jarg1;
20333   {
20334     try {
20335       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
20336     } catch (std::out_of_range& e) {
20337       {
20338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20339       };
20340     } catch (std::exception& e) {
20341       {
20342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20343       };
20344     } catch (Dali::DaliException e) {
20345       {
20346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20347       };
20348     } catch (...) {
20349       {
20350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20351       };
20352     }
20353   }
20354
20355   jresult = result;
20356   return jresult;
20357 }
20358
20359
20360 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
20361   char * jresult ;
20362   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20363   Dali::Property::Index arg2 ;
20364   std::string result;
20365
20366   arg1 = (Dali::Handle *)jarg1;
20367   arg2 = (Dali::Property::Index)jarg2;
20368   {
20369     try {
20370       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
20371     } catch (std::out_of_range& e) {
20372       {
20373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20374       };
20375     } catch (std::exception& e) {
20376       {
20377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20378       };
20379     } catch (Dali::DaliException e) {
20380       {
20381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20382       };
20383     } catch (...) {
20384       {
20385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20386       };
20387     }
20388   }
20389
20390   jresult = SWIG_csharp_string_callback((&result)->c_str());
20391   return jresult;
20392 }
20393
20394
20395 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
20396   int jresult ;
20397   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20398   std::string *arg2 = 0 ;
20399   Dali::Property::Index result;
20400
20401   arg1 = (Dali::Handle *)jarg1;
20402   if (!jarg2) {
20403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20404     return 0;
20405   }
20406   std::string arg2_str(jarg2);
20407   arg2 = &arg2_str;
20408   {
20409     try {
20410       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
20411     } catch (std::out_of_range& e) {
20412       {
20413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20414       };
20415     } catch (std::exception& e) {
20416       {
20417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20418       };
20419     } catch (Dali::DaliException e) {
20420       {
20421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20422       };
20423     } catch (...) {
20424       {
20425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20426       };
20427     }
20428   }
20429
20430   jresult = result;
20431
20432   //argout typemap for const std::string&
20433
20434   return jresult;
20435 }
20436
20437
20438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
20439   unsigned int jresult ;
20440   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20441   Dali::Property::Index arg2 ;
20442   bool result;
20443
20444   arg1 = (Dali::Handle *)jarg1;
20445   arg2 = (Dali::Property::Index)jarg2;
20446   {
20447     try {
20448       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
20449     } catch (std::out_of_range& e) {
20450       {
20451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20452       };
20453     } catch (std::exception& e) {
20454       {
20455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20456       };
20457     } catch (Dali::DaliException e) {
20458       {
20459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20460       };
20461     } catch (...) {
20462       {
20463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20464       };
20465     }
20466   }
20467
20468   jresult = result;
20469   return jresult;
20470 }
20471
20472
20473 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
20474   unsigned int jresult ;
20475   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20476   Dali::Property::Index arg2 ;
20477   bool result;
20478
20479   arg1 = (Dali::Handle *)jarg1;
20480   arg2 = (Dali::Property::Index)jarg2;
20481   {
20482     try {
20483       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
20484     } catch (std::out_of_range& e) {
20485       {
20486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20487       };
20488     } catch (std::exception& e) {
20489       {
20490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20491       };
20492     } catch (Dali::DaliException e) {
20493       {
20494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20495       };
20496     } catch (...) {
20497       {
20498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20499       };
20500     }
20501   }
20502
20503   jresult = result;
20504   return jresult;
20505 }
20506
20507
20508 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
20509   unsigned int jresult ;
20510   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20511   Dali::Property::Index arg2 ;
20512   bool result;
20513
20514   arg1 = (Dali::Handle *)jarg1;
20515   arg2 = (Dali::Property::Index)jarg2;
20516   {
20517     try {
20518       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
20519     } catch (std::out_of_range& e) {
20520       {
20521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20522       };
20523     } catch (std::exception& e) {
20524       {
20525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20526       };
20527     } catch (Dali::DaliException e) {
20528       {
20529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20530       };
20531     } catch (...) {
20532       {
20533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20534       };
20535     }
20536   }
20537
20538   jresult = result;
20539   return jresult;
20540 }
20541
20542
20543 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
20544   int jresult ;
20545   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20546   Dali::Property::Index arg2 ;
20547   Dali::Property::Type result;
20548
20549   arg1 = (Dali::Handle *)jarg1;
20550   arg2 = (Dali::Property::Index)jarg2;
20551   {
20552     try {
20553       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
20554     } catch (std::out_of_range& e) {
20555       {
20556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20557       };
20558     } catch (std::exception& e) {
20559       {
20560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20561       };
20562     } catch (Dali::DaliException e) {
20563       {
20564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20565       };
20566     } catch (...) {
20567       {
20568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20569       };
20570     }
20571   }
20572
20573   jresult = (int)result;
20574   return jresult;
20575 }
20576
20577
20578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
20579   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20580   Dali::Property::Index arg2 ;
20581   Dali::Property::Value *arg3 = 0 ;
20582
20583   arg1 = (Dali::Handle *)jarg1;
20584   arg2 = (Dali::Property::Index)jarg2;
20585   arg3 = (Dali::Property::Value *)jarg3;
20586   if (!arg3) {
20587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20588     return ;
20589   }
20590   {
20591     try {
20592       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
20593     } catch (std::out_of_range& e) {
20594       {
20595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20596       };
20597     } catch (std::exception& e) {
20598       {
20599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20600       };
20601     } catch (Dali::DaliException e) {
20602       {
20603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20604       };
20605     } catch (...) {
20606       {
20607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20608       };
20609     }
20610   }
20611
20612 }
20613
20614
20615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
20616   int jresult ;
20617   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20618   std::string *arg2 = 0 ;
20619   Dali::Property::Value *arg3 = 0 ;
20620   Dali::Property::Index result;
20621
20622   arg1 = (Dali::Handle *)jarg1;
20623   if (!jarg2) {
20624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20625     return 0;
20626   }
20627   std::string arg2_str(jarg2);
20628   arg2 = &arg2_str;
20629   arg3 = (Dali::Property::Value *)jarg3;
20630   if (!arg3) {
20631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20632     return 0;
20633   }
20634   {
20635     try {
20636       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
20637     } catch (std::out_of_range& e) {
20638       {
20639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20640       };
20641     } catch (std::exception& e) {
20642       {
20643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20644       };
20645     } catch (Dali::DaliException e) {
20646       {
20647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20648       };
20649     } catch (...) {
20650       {
20651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20652       };
20653     }
20654   }
20655
20656   jresult = result;
20657
20658   //argout typemap for const std::string&
20659
20660   return jresult;
20661 }
20662
20663
20664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
20665   int jresult ;
20666   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20667   std::string *arg2 = 0 ;
20668   Dali::Property::Value *arg3 = 0 ;
20669   Dali::Property::AccessMode arg4 ;
20670   Dali::Property::Index result;
20671
20672   arg1 = (Dali::Handle *)jarg1;
20673   if (!jarg2) {
20674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20675     return 0;
20676   }
20677   std::string arg2_str(jarg2);
20678   arg2 = &arg2_str;
20679   arg3 = (Dali::Property::Value *)jarg3;
20680   if (!arg3) {
20681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20682     return 0;
20683   }
20684   arg4 = (Dali::Property::AccessMode)jarg4;
20685   {
20686     try {
20687       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
20688     } catch (std::out_of_range& e) {
20689       {
20690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20691       };
20692     } catch (std::exception& e) {
20693       {
20694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20695       };
20696     } catch (Dali::DaliException e) {
20697       {
20698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20699       };
20700     } catch (...) {
20701       {
20702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20703       };
20704     }
20705   }
20706
20707   jresult = result;
20708
20709   //argout typemap for const std::string&
20710
20711   return jresult;
20712 }
20713
20714
20715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
20716   void * jresult ;
20717   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20718   Dali::Property::Index arg2 ;
20719   Dali::Property::Value result;
20720
20721   arg1 = (Dali::Handle *)jarg1;
20722   arg2 = (Dali::Property::Index)jarg2;
20723   {
20724     try {
20725       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
20726     } catch (std::out_of_range& e) {
20727       {
20728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20729       };
20730     } catch (std::exception& e) {
20731       {
20732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20733       };
20734     } catch (Dali::DaliException e) {
20735       {
20736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20737       };
20738     } catch (...) {
20739       {
20740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20741       };
20742     }
20743   }
20744
20745   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
20746   return jresult;
20747 }
20748
20749
20750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
20751   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20752   Dali::Property::IndexContainer *arg2 = 0 ;
20753
20754   arg1 = (Dali::Handle *)jarg1;
20755   arg2 = (Dali::Property::IndexContainer *)jarg2;
20756   if (!arg2) {
20757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
20758     return ;
20759   }
20760   {
20761     try {
20762       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
20763     } catch (std::out_of_range& e) {
20764       {
20765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20766       };
20767     } catch (std::exception& e) {
20768       {
20769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20770       };
20771     } catch (Dali::DaliException e) {
20772       {
20773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20774       };
20775     } catch (...) {
20776       {
20777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20778       };
20779     }
20780   }
20781
20782 }
20783
20784
20785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
20786   void * jresult ;
20787   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20788   Dali::Property::Index arg2 ;
20789   Dali::PropertyCondition *arg3 = 0 ;
20790   Dali::PropertyNotification result;
20791
20792   arg1 = (Dali::Handle *)jarg1;
20793   arg2 = (Dali::Property::Index)jarg2;
20794   arg3 = (Dali::PropertyCondition *)jarg3;
20795   if (!arg3) {
20796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20797     return 0;
20798   }
20799   {
20800     try {
20801       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
20802     } catch (std::out_of_range& e) {
20803       {
20804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20805       };
20806     } catch (std::exception& e) {
20807       {
20808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20809       };
20810     } catch (Dali::DaliException e) {
20811       {
20812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20813       };
20814     } catch (...) {
20815       {
20816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20817       };
20818     }
20819   }
20820
20821   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
20822   return jresult;
20823 }
20824
20825
20826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
20827   void * jresult ;
20828   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20829   Dali::Property::Index arg2 ;
20830   int arg3 ;
20831   Dali::PropertyCondition *arg4 = 0 ;
20832   Dali::PropertyNotification result;
20833
20834   arg1 = (Dali::Handle *)jarg1;
20835   arg2 = (Dali::Property::Index)jarg2;
20836   arg3 = (int)jarg3;
20837   arg4 = (Dali::PropertyCondition *)jarg4;
20838   if (!arg4) {
20839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20840     return 0;
20841   }
20842   {
20843     try {
20844       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
20845     } catch (std::out_of_range& e) {
20846       {
20847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20848       };
20849     } catch (std::exception& e) {
20850       {
20851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20852       };
20853     } catch (Dali::DaliException e) {
20854       {
20855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20856       };
20857     } catch (...) {
20858       {
20859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20860       };
20861     }
20862   }
20863
20864   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
20865   return jresult;
20866 }
20867
20868
20869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
20870   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20871   Dali::PropertyNotification arg2 ;
20872   Dali::PropertyNotification *argp2 ;
20873
20874   arg1 = (Dali::Handle *)jarg1;
20875   argp2 = (Dali::PropertyNotification *)jarg2;
20876   if (!argp2) {
20877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
20878     return ;
20879   }
20880   arg2 = *argp2;
20881   {
20882     try {
20883       (arg1)->RemovePropertyNotification(arg2);
20884     } catch (std::out_of_range& e) {
20885       {
20886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20887       };
20888     } catch (std::exception& e) {
20889       {
20890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20891       };
20892     } catch (Dali::DaliException e) {
20893       {
20894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20895       };
20896     } catch (...) {
20897       {
20898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20899       };
20900     }
20901   }
20902
20903 }
20904
20905
20906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
20907   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20908
20909   arg1 = (Dali::Handle *)jarg1;
20910   {
20911     try {
20912       (arg1)->RemovePropertyNotifications();
20913     } catch (std::out_of_range& e) {
20914       {
20915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20916       };
20917     } catch (std::exception& e) {
20918       {
20919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20920       };
20921     } catch (Dali::DaliException e) {
20922       {
20923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20924       };
20925     } catch (...) {
20926       {
20927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20928       };
20929     }
20930   }
20931
20932 }
20933
20934
20935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
20936   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20937
20938   arg1 = (Dali::Handle *)jarg1;
20939   {
20940     try {
20941       (arg1)->RemoveConstraints();
20942     } catch (std::out_of_range& e) {
20943       {
20944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20945       };
20946     } catch (std::exception& e) {
20947       {
20948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20949       };
20950     } catch (Dali::DaliException e) {
20951       {
20952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20953       };
20954     } catch (...) {
20955       {
20956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20957       };
20958     }
20959   }
20960
20961 }
20962
20963
20964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
20965   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20966   unsigned int arg2 ;
20967
20968   arg1 = (Dali::Handle *)jarg1;
20969   arg2 = (unsigned int)jarg2;
20970   {
20971     try {
20972       (arg1)->RemoveConstraints(arg2);
20973     } catch (std::out_of_range& e) {
20974       {
20975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20976       };
20977     } catch (std::exception& e) {
20978       {
20979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20980       };
20981     } catch (Dali::DaliException e) {
20982       {
20983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20984       };
20985     } catch (...) {
20986       {
20987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20988       };
20989     }
20990   }
20991
20992 }
20993
20994
20995 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
20996   int jresult ;
20997   Dali::Property::Index result;
20998
20999   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
21000   jresult = result;
21001   return jresult;
21002 }
21003
21004
21005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
21006   void * jresult ;
21007   Dali::Handle result;
21008
21009   {
21010     try {
21011       result = Dali::WeightObject::New();
21012     } catch (std::out_of_range& e) {
21013       {
21014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21015       };
21016     } catch (std::exception& e) {
21017       {
21018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21019       };
21020     } catch (Dali::DaliException e) {
21021       {
21022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21023       };
21024     } catch (...) {
21025       {
21026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21027       };
21028     }
21029   }
21030
21031   jresult = new Dali::Handle((const Dali::Handle &)result);
21032   return jresult;
21033 }
21034
21035
21036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
21037   void * jresult ;
21038   Dali::TypeInfo *result = 0 ;
21039
21040   {
21041     try {
21042       result = (Dali::TypeInfo *)new Dali::TypeInfo();
21043     } catch (std::out_of_range& e) {
21044       {
21045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21046       };
21047     } catch (std::exception& e) {
21048       {
21049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21050       };
21051     } catch (Dali::DaliException e) {
21052       {
21053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21054       };
21055     } catch (...) {
21056       {
21057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21058       };
21059     }
21060   }
21061
21062   jresult = (void *)result;
21063   return jresult;
21064 }
21065
21066
21067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
21068   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21069
21070   arg1 = (Dali::TypeInfo *)jarg1;
21071   {
21072     try {
21073       delete arg1;
21074     } catch (std::out_of_range& e) {
21075       {
21076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21077       };
21078     } catch (std::exception& e) {
21079       {
21080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21081       };
21082     } catch (Dali::DaliException e) {
21083       {
21084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21085       };
21086     } catch (...) {
21087       {
21088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21089       };
21090     }
21091   }
21092
21093 }
21094
21095
21096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
21097   void * jresult ;
21098   Dali::TypeInfo *arg1 = 0 ;
21099   Dali::TypeInfo *result = 0 ;
21100
21101   arg1 = (Dali::TypeInfo *)jarg1;
21102   if (!arg1) {
21103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21104     return 0;
21105   }
21106   {
21107     try {
21108       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
21109     } catch (std::out_of_range& e) {
21110       {
21111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21112       };
21113     } catch (std::exception& e) {
21114       {
21115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21116       };
21117     } catch (Dali::DaliException e) {
21118       {
21119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21120       };
21121     } catch (...) {
21122       {
21123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21124       };
21125     }
21126   }
21127
21128   jresult = (void *)result;
21129   return jresult;
21130 }
21131
21132
21133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
21134   void * jresult ;
21135   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21136   Dali::TypeInfo *arg2 = 0 ;
21137   Dali::TypeInfo *result = 0 ;
21138
21139   arg1 = (Dali::TypeInfo *)jarg1;
21140   arg2 = (Dali::TypeInfo *)jarg2;
21141   if (!arg2) {
21142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21143     return 0;
21144   }
21145   {
21146     try {
21147       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
21148     } catch (std::out_of_range& e) {
21149       {
21150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21151       };
21152     } catch (std::exception& e) {
21153       {
21154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21155       };
21156     } catch (Dali::DaliException e) {
21157       {
21158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21159       };
21160     } catch (...) {
21161       {
21162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21163       };
21164     }
21165   }
21166
21167   jresult = (void *)result;
21168   return jresult;
21169 }
21170
21171
21172 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
21173   char * jresult ;
21174   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21175   std::string *result = 0 ;
21176
21177   arg1 = (Dali::TypeInfo *)jarg1;
21178   {
21179     try {
21180       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
21181     } catch (std::out_of_range& e) {
21182       {
21183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21184       };
21185     } catch (std::exception& e) {
21186       {
21187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21188       };
21189     } catch (Dali::DaliException e) {
21190       {
21191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21192       };
21193     } catch (...) {
21194       {
21195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21196       };
21197     }
21198   }
21199
21200   jresult = SWIG_csharp_string_callback(result->c_str());
21201   return jresult;
21202 }
21203
21204
21205 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
21206   char * jresult ;
21207   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21208   std::string *result = 0 ;
21209
21210   arg1 = (Dali::TypeInfo *)jarg1;
21211   {
21212     try {
21213       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
21214     } catch (std::out_of_range& e) {
21215       {
21216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21217       };
21218     } catch (std::exception& e) {
21219       {
21220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21221       };
21222     } catch (Dali::DaliException e) {
21223       {
21224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21225       };
21226     } catch (...) {
21227       {
21228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21229       };
21230     }
21231   }
21232
21233   jresult = SWIG_csharp_string_callback(result->c_str());
21234   return jresult;
21235 }
21236
21237
21238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
21239   void * jresult ;
21240   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21241   Dali::BaseHandle result;
21242
21243   arg1 = (Dali::TypeInfo *)jarg1;
21244   {
21245     try {
21246       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
21247     } catch (std::out_of_range& e) {
21248       {
21249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21250       };
21251     } catch (std::exception& e) {
21252       {
21253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21254       };
21255     } catch (Dali::DaliException e) {
21256       {
21257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21258       };
21259     } catch (...) {
21260       {
21261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21262       };
21263     }
21264   }
21265
21266   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
21267   return jresult;
21268 }
21269
21270
21271 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
21272   unsigned long jresult ;
21273   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21274   size_t result;
21275
21276   arg1 = (Dali::TypeInfo *)jarg1;
21277   {
21278     try {
21279       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
21280     } catch (std::out_of_range& e) {
21281       {
21282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21283       };
21284     } catch (std::exception& e) {
21285       {
21286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21287       };
21288     } catch (Dali::DaliException e) {
21289       {
21290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21291       };
21292     } catch (...) {
21293       {
21294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21295       };
21296     }
21297   }
21298
21299   jresult = (unsigned long)result;
21300   return jresult;
21301 }
21302
21303
21304 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
21305   char * jresult ;
21306   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21307   size_t arg2 ;
21308   std::string result;
21309
21310   arg1 = (Dali::TypeInfo *)jarg1;
21311   arg2 = (size_t)jarg2;
21312   {
21313     try {
21314       result = (arg1)->GetActionName(arg2);
21315     } catch (std::out_of_range& e) {
21316       {
21317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21318       };
21319     } catch (std::exception& e) {
21320       {
21321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21322       };
21323     } catch (Dali::DaliException e) {
21324       {
21325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21326       };
21327     } catch (...) {
21328       {
21329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21330       };
21331     }
21332   }
21333
21334   jresult = SWIG_csharp_string_callback((&result)->c_str());
21335   return jresult;
21336 }
21337
21338
21339 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
21340   unsigned long jresult ;
21341   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21342   size_t result;
21343
21344   arg1 = (Dali::TypeInfo *)jarg1;
21345   {
21346     try {
21347       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
21348     } catch (std::out_of_range& e) {
21349       {
21350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21351       };
21352     } catch (std::exception& e) {
21353       {
21354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21355       };
21356     } catch (Dali::DaliException e) {
21357       {
21358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21359       };
21360     } catch (...) {
21361       {
21362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21363       };
21364     }
21365   }
21366
21367   jresult = (unsigned long)result;
21368   return jresult;
21369 }
21370
21371
21372 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
21373   char * jresult ;
21374   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21375   size_t arg2 ;
21376   std::string result;
21377
21378   arg1 = (Dali::TypeInfo *)jarg1;
21379   arg2 = (size_t)jarg2;
21380   {
21381     try {
21382       result = (arg1)->GetSignalName(arg2);
21383     } catch (std::out_of_range& e) {
21384       {
21385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21386       };
21387     } catch (std::exception& e) {
21388       {
21389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21390       };
21391     } catch (Dali::DaliException e) {
21392       {
21393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21394       };
21395     } catch (...) {
21396       {
21397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21398       };
21399     }
21400   }
21401
21402   jresult = SWIG_csharp_string_callback((&result)->c_str());
21403   return jresult;
21404 }
21405
21406
21407 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
21408   unsigned long jresult ;
21409   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21410   size_t result;
21411
21412   arg1 = (Dali::TypeInfo *)jarg1;
21413   {
21414     try {
21415       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
21416     } catch (std::out_of_range& e) {
21417       {
21418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21419       };
21420     } catch (std::exception& e) {
21421       {
21422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21423       };
21424     } catch (Dali::DaliException e) {
21425       {
21426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21427       };
21428     } catch (...) {
21429       {
21430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21431       };
21432     }
21433   }
21434
21435   jresult = (unsigned long)result;
21436   return jresult;
21437 }
21438
21439
21440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
21441   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21442   Dali::Property::IndexContainer *arg2 = 0 ;
21443
21444   arg1 = (Dali::TypeInfo *)jarg1;
21445   arg2 = (Dali::Property::IndexContainer *)jarg2;
21446   if (!arg2) {
21447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
21448     return ;
21449   }
21450   {
21451     try {
21452       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
21453     } catch (std::out_of_range& e) {
21454       {
21455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21456       };
21457     } catch (std::exception& e) {
21458       {
21459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21460       };
21461     } catch (Dali::DaliException e) {
21462       {
21463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21464       };
21465     } catch (...) {
21466       {
21467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21468       };
21469     }
21470   }
21471
21472 }
21473
21474
21475 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
21476   char * jresult ;
21477   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21478   Dali::Property::Index arg2 ;
21479   std::string *result = 0 ;
21480
21481   arg1 = (Dali::TypeInfo *)jarg1;
21482   arg2 = (Dali::Property::Index)jarg2;
21483   {
21484     try {
21485       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
21486     } catch (std::out_of_range& e) {
21487       {
21488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21489       };
21490     } catch (std::exception& e) {
21491       {
21492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21493       };
21494     } catch (Dali::DaliException e) {
21495       {
21496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21497       };
21498     } catch (...) {
21499       {
21500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21501       };
21502     }
21503   }
21504
21505   jresult = SWIG_csharp_string_callback(result->c_str());
21506   return jresult;
21507 }
21508
21509
21510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
21511   void * jresult ;
21512   Dali::TypeRegistry result;
21513
21514   {
21515     try {
21516       result = Dali::TypeRegistry::Get();
21517     } catch (std::out_of_range& e) {
21518       {
21519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21520       };
21521     } catch (std::exception& e) {
21522       {
21523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21524       };
21525     } catch (Dali::DaliException e) {
21526       {
21527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21528       };
21529     } catch (...) {
21530       {
21531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21532       };
21533     }
21534   }
21535
21536   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
21537   return jresult;
21538 }
21539
21540
21541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
21542   void * jresult ;
21543   Dali::TypeRegistry *result = 0 ;
21544
21545   {
21546     try {
21547       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
21548     } catch (std::out_of_range& e) {
21549       {
21550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21551       };
21552     } catch (std::exception& e) {
21553       {
21554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21555       };
21556     } catch (Dali::DaliException e) {
21557       {
21558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21559       };
21560     } catch (...) {
21561       {
21562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21563       };
21564     }
21565   }
21566
21567   jresult = (void *)result;
21568   return jresult;
21569 }
21570
21571
21572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
21573   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21574
21575   arg1 = (Dali::TypeRegistry *)jarg1;
21576   {
21577     try {
21578       delete arg1;
21579     } catch (std::out_of_range& e) {
21580       {
21581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21582       };
21583     } catch (std::exception& e) {
21584       {
21585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21586       };
21587     } catch (Dali::DaliException e) {
21588       {
21589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21590       };
21591     } catch (...) {
21592       {
21593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21594       };
21595     }
21596   }
21597
21598 }
21599
21600
21601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
21602   void * jresult ;
21603   Dali::TypeRegistry *arg1 = 0 ;
21604   Dali::TypeRegistry *result = 0 ;
21605
21606   arg1 = (Dali::TypeRegistry *)jarg1;
21607   if (!arg1) {
21608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21609     return 0;
21610   }
21611   {
21612     try {
21613       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
21614     } catch (std::out_of_range& e) {
21615       {
21616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21617       };
21618     } catch (std::exception& e) {
21619       {
21620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21621       };
21622     } catch (Dali::DaliException e) {
21623       {
21624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21625       };
21626     } catch (...) {
21627       {
21628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21629       };
21630     }
21631   }
21632
21633   jresult = (void *)result;
21634   return jresult;
21635 }
21636
21637
21638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
21639   void * jresult ;
21640   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21641   Dali::TypeRegistry *arg2 = 0 ;
21642   Dali::TypeRegistry *result = 0 ;
21643
21644   arg1 = (Dali::TypeRegistry *)jarg1;
21645   arg2 = (Dali::TypeRegistry *)jarg2;
21646   if (!arg2) {
21647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21648     return 0;
21649   }
21650   {
21651     try {
21652       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
21653     } catch (std::out_of_range& e) {
21654       {
21655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21656       };
21657     } catch (std::exception& e) {
21658       {
21659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21660       };
21661     } catch (Dali::DaliException e) {
21662       {
21663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21664       };
21665     } catch (...) {
21666       {
21667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21668       };
21669     }
21670   }
21671
21672   jresult = (void *)result;
21673   return jresult;
21674 }
21675
21676
21677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
21678   void * jresult ;
21679   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21680   std::string *arg2 = 0 ;
21681   Dali::TypeInfo result;
21682
21683   arg1 = (Dali::TypeRegistry *)jarg1;
21684   if (!jarg2) {
21685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21686     return 0;
21687   }
21688   std::string arg2_str(jarg2);
21689   arg2 = &arg2_str;
21690   {
21691     try {
21692       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
21693     } catch (std::out_of_range& e) {
21694       {
21695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21696       };
21697     } catch (std::exception& e) {
21698       {
21699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21700       };
21701     } catch (Dali::DaliException e) {
21702       {
21703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21704       };
21705     } catch (...) {
21706       {
21707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21708       };
21709     }
21710   }
21711
21712   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21713
21714   //argout typemap for const std::string&
21715
21716   return jresult;
21717 }
21718
21719
21720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
21721   void * jresult ;
21722   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21723   std::type_info *arg2 = 0 ;
21724   Dali::TypeInfo result;
21725
21726   arg1 = (Dali::TypeRegistry *)jarg1;
21727   arg2 = (std::type_info *)jarg2;
21728   if (!arg2) {
21729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21730     return 0;
21731   }
21732   {
21733     try {
21734       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
21735     } catch (std::out_of_range& e) {
21736       {
21737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21738       };
21739     } catch (std::exception& e) {
21740       {
21741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21742       };
21743     } catch (Dali::DaliException e) {
21744       {
21745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21746       };
21747     } catch (...) {
21748       {
21749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21750       };
21751     }
21752   }
21753
21754   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21755   return jresult;
21756 }
21757
21758
21759 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
21760   unsigned long jresult ;
21761   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21762   size_t result;
21763
21764   arg1 = (Dali::TypeRegistry *)jarg1;
21765   {
21766     try {
21767       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
21768     } catch (std::out_of_range& e) {
21769       {
21770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21771       };
21772     } catch (std::exception& e) {
21773       {
21774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21775       };
21776     } catch (Dali::DaliException e) {
21777       {
21778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21779       };
21780     } catch (...) {
21781       {
21782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21783       };
21784     }
21785   }
21786
21787   jresult = (unsigned long)result;
21788   return jresult;
21789 }
21790
21791
21792 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
21793   char * jresult ;
21794   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21795   size_t arg2 ;
21796   std::string result;
21797
21798   arg1 = (Dali::TypeRegistry *)jarg1;
21799   arg2 = (size_t)jarg2;
21800   {
21801     try {
21802       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
21803     } catch (std::out_of_range& e) {
21804       {
21805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21806       };
21807     } catch (std::exception& e) {
21808       {
21809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21810       };
21811     } catch (Dali::DaliException e) {
21812       {
21813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21814       };
21815     } catch (...) {
21816       {
21817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21818       };
21819     }
21820   }
21821
21822   jresult = SWIG_csharp_string_callback((&result)->c_str());
21823   return jresult;
21824 }
21825
21826
21827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_2(void * jarg1) {
21828   void * jresult ;
21829   Dali::Internal::TypeRegistry *arg1 = (Dali::Internal::TypeRegistry *) 0 ;
21830   Dali::TypeRegistry *result = 0 ;
21831
21832   arg1 = (Dali::Internal::TypeRegistry *)jarg1;
21833   {
21834     try {
21835       result = (Dali::TypeRegistry *)new Dali::TypeRegistry(arg1);
21836     } catch (std::out_of_range& e) {
21837       {
21838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21839       };
21840     } catch (std::exception& e) {
21841       {
21842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21843       };
21844     } catch (Dali::DaliException e) {
21845       {
21846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21847       };
21848     } catch (...) {
21849       {
21850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21851       };
21852     }
21853   }
21854
21855   jresult = (void *)result;
21856   return jresult;
21857 }
21858
21859
21860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
21861   void * jresult ;
21862   std::type_info *arg1 = 0 ;
21863   std::type_info *arg2 = 0 ;
21864   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
21865   Dali::TypeRegistration *result = 0 ;
21866
21867   arg1 = (std::type_info *)jarg1;
21868   if (!arg1) {
21869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21870     return 0;
21871   }
21872   arg2 = (std::type_info *)jarg2;
21873   if (!arg2) {
21874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21875     return 0;
21876   }
21877   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
21878   {
21879     try {
21880       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
21881     } catch (std::out_of_range& e) {
21882       {
21883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21884       };
21885     } catch (std::exception& e) {
21886       {
21887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21888       };
21889     } catch (Dali::DaliException e) {
21890       {
21891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21892       };
21893     } catch (...) {
21894       {
21895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21896       };
21897     }
21898   }
21899
21900   jresult = (void *)result;
21901   return jresult;
21902 }
21903
21904
21905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
21906   void * jresult ;
21907   std::type_info *arg1 = 0 ;
21908   std::type_info *arg2 = 0 ;
21909   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
21910   bool arg4 ;
21911   Dali::TypeRegistration *result = 0 ;
21912
21913   arg1 = (std::type_info *)jarg1;
21914   if (!arg1) {
21915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21916     return 0;
21917   }
21918   arg2 = (std::type_info *)jarg2;
21919   if (!arg2) {
21920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21921     return 0;
21922   }
21923   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
21924   arg4 = jarg4 ? true : false;
21925   {
21926     try {
21927       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
21928     } catch (std::out_of_range& e) {
21929       {
21930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21931       };
21932     } catch (std::exception& e) {
21933       {
21934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21935       };
21936     } catch (Dali::DaliException e) {
21937       {
21938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21939       };
21940     } catch (...) {
21941       {
21942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21943       };
21944     }
21945   }
21946
21947   jresult = (void *)result;
21948   return jresult;
21949 }
21950
21951
21952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
21953   void * jresult ;
21954   std::string *arg1 = 0 ;
21955   std::type_info *arg2 = 0 ;
21956   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
21957   Dali::TypeRegistration *result = 0 ;
21958
21959   if (!jarg1) {
21960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21961     return 0;
21962   }
21963   std::string arg1_str(jarg1);
21964   arg1 = &arg1_str;
21965   arg2 = (std::type_info *)jarg2;
21966   if (!arg2) {
21967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21968     return 0;
21969   }
21970   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
21971   {
21972     try {
21973       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
21974     } catch (std::out_of_range& e) {
21975       {
21976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21977       };
21978     } catch (std::exception& e) {
21979       {
21980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21981       };
21982     } catch (Dali::DaliException e) {
21983       {
21984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21985       };
21986     } catch (...) {
21987       {
21988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21989       };
21990     }
21991   }
21992
21993   jresult = (void *)result;
21994
21995   //argout typemap for const std::string&
21996
21997   return jresult;
21998 }
21999
22000
22001 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
22002   char * jresult ;
22003   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22004   std::string result;
22005
22006   arg1 = (Dali::TypeRegistration *)jarg1;
22007   {
22008     try {
22009       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
22010     } catch (std::out_of_range& e) {
22011       {
22012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22013       };
22014     } catch (std::exception& e) {
22015       {
22016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22017       };
22018     } catch (Dali::DaliException e) {
22019       {
22020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22021       };
22022     } catch (...) {
22023       {
22024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22025       };
22026     }
22027   }
22028
22029   jresult = SWIG_csharp_string_callback((&result)->c_str());
22030   return jresult;
22031 }
22032
22033
22034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
22035   std::string *arg1 = 0 ;
22036   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22037
22038   if (!jarg1) {
22039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22040     return ;
22041   }
22042   std::string arg1_str(jarg1);
22043   arg1 = &arg1_str;
22044   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
22045   {
22046     try {
22047       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
22048     } catch (std::out_of_range& e) {
22049       {
22050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22051       };
22052     } catch (std::exception& e) {
22053       {
22054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22055       };
22056     } catch (Dali::DaliException e) {
22057       {
22058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22059       };
22060     } catch (...) {
22061       {
22062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22063       };
22064     }
22065   }
22066
22067
22068   //argout typemap for const std::string&
22069
22070 }
22071
22072
22073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22074   std::string *arg1 = 0 ;
22075   std::string *arg2 = 0 ;
22076   int arg3 ;
22077   Dali::Property::Type arg4 ;
22078   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22079   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22080
22081   if (!jarg1) {
22082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22083     return ;
22084   }
22085   std::string arg1_str(jarg1);
22086   arg1 = &arg1_str;
22087   if (!jarg2) {
22088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22089     return ;
22090   }
22091   std::string arg2_str(jarg2);
22092   arg2 = &arg2_str;
22093   arg3 = (int)jarg3;
22094   arg4 = (Dali::Property::Type)jarg4;
22095   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22096   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22097   {
22098     try {
22099       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22100     } catch (std::out_of_range& e) {
22101       {
22102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22103       };
22104     } catch (std::exception& e) {
22105       {
22106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22107       };
22108     } catch (Dali::DaliException e) {
22109       {
22110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22111       };
22112     } catch (...) {
22113       {
22114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22115       };
22116     }
22117   }
22118
22119
22120   //argout typemap for const std::string&
22121
22122
22123   //argout typemap for const std::string&
22124
22125 }
22126
22127
22128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
22129   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22130
22131   arg1 = (Dali::TypeRegistration *)jarg1;
22132   {
22133     try {
22134       delete arg1;
22135     } catch (std::out_of_range& e) {
22136       {
22137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22138       };
22139     } catch (std::exception& e) {
22140       {
22141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22142       };
22143     } catch (Dali::DaliException e) {
22144       {
22145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22146       };
22147     } catch (...) {
22148       {
22149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22150       };
22151     }
22152   }
22153
22154 }
22155
22156
22157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
22158   void * jresult ;
22159   Dali::TypeRegistration *arg1 = 0 ;
22160   std::string *arg2 = 0 ;
22161   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
22162   Dali::SignalConnectorType *result = 0 ;
22163
22164   arg1 = (Dali::TypeRegistration *)jarg1;
22165   if (!arg1) {
22166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22167     return 0;
22168   }
22169   if (!jarg2) {
22170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22171     return 0;
22172   }
22173   std::string arg2_str(jarg2);
22174   arg2 = &arg2_str;
22175   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
22176   {
22177     try {
22178       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
22179     } catch (std::out_of_range& e) {
22180       {
22181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22182       };
22183     } catch (std::exception& e) {
22184       {
22185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22186       };
22187     } catch (Dali::DaliException e) {
22188       {
22189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22190       };
22191     } catch (...) {
22192       {
22193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22194       };
22195     }
22196   }
22197
22198   jresult = (void *)result;
22199
22200   //argout typemap for const std::string&
22201
22202   return jresult;
22203 }
22204
22205
22206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
22207   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
22208
22209   arg1 = (Dali::SignalConnectorType *)jarg1;
22210   {
22211     try {
22212       delete arg1;
22213     } catch (std::out_of_range& e) {
22214       {
22215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22216       };
22217     } catch (std::exception& e) {
22218       {
22219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22220       };
22221     } catch (Dali::DaliException e) {
22222       {
22223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22224       };
22225     } catch (...) {
22226       {
22227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22228       };
22229     }
22230   }
22231
22232 }
22233
22234
22235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
22236   void * jresult ;
22237   Dali::TypeRegistration *arg1 = 0 ;
22238   std::string *arg2 = 0 ;
22239   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
22240   Dali::TypeAction *result = 0 ;
22241
22242   arg1 = (Dali::TypeRegistration *)jarg1;
22243   if (!arg1) {
22244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22245     return 0;
22246   }
22247   if (!jarg2) {
22248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22249     return 0;
22250   }
22251   std::string arg2_str(jarg2);
22252   arg2 = &arg2_str;
22253   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
22254   {
22255     try {
22256       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
22257     } catch (std::out_of_range& e) {
22258       {
22259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22260       };
22261     } catch (std::exception& e) {
22262       {
22263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22264       };
22265     } catch (Dali::DaliException e) {
22266       {
22267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22268       };
22269     } catch (...) {
22270       {
22271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22272       };
22273     }
22274   }
22275
22276   jresult = (void *)result;
22277
22278   //argout typemap for const std::string&
22279
22280   return jresult;
22281 }
22282
22283
22284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
22285   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
22286
22287   arg1 = (Dali::TypeAction *)jarg1;
22288   {
22289     try {
22290       delete arg1;
22291     } catch (std::out_of_range& e) {
22292       {
22293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22294       };
22295     } catch (std::exception& e) {
22296       {
22297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22298       };
22299     } catch (Dali::DaliException e) {
22300       {
22301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22302       };
22303     } catch (...) {
22304       {
22305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22306       };
22307     }
22308   }
22309
22310 }
22311
22312
22313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22314   void * jresult ;
22315   Dali::TypeRegistration *arg1 = 0 ;
22316   std::string *arg2 = 0 ;
22317   Dali::Property::Index arg3 ;
22318   Dali::Property::Type arg4 ;
22319   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
22320   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
22321   Dali::PropertyRegistration *result = 0 ;
22322
22323   arg1 = (Dali::TypeRegistration *)jarg1;
22324   if (!arg1) {
22325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22326     return 0;
22327   }
22328   if (!jarg2) {
22329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22330     return 0;
22331   }
22332   std::string arg2_str(jarg2);
22333   arg2 = &arg2_str;
22334   arg3 = (Dali::Property::Index)jarg3;
22335   arg4 = (Dali::Property::Type)jarg4;
22336   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
22337   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
22338   {
22339     try {
22340       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22341     } catch (std::out_of_range& e) {
22342       {
22343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22344       };
22345     } catch (std::exception& e) {
22346       {
22347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22348       };
22349     } catch (Dali::DaliException e) {
22350       {
22351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22352       };
22353     } catch (...) {
22354       {
22355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22356       };
22357     }
22358   }
22359
22360   jresult = (void *)result;
22361
22362   //argout typemap for const std::string&
22363
22364   return jresult;
22365 }
22366
22367
22368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
22369   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
22370
22371   arg1 = (Dali::PropertyRegistration *)jarg1;
22372   {
22373     try {
22374       delete arg1;
22375     } catch (std::out_of_range& e) {
22376       {
22377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22378       };
22379     } catch (std::exception& e) {
22380       {
22381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22382       };
22383     } catch (Dali::DaliException e) {
22384       {
22385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22386       };
22387     } catch (...) {
22388       {
22389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22390       };
22391     }
22392   }
22393
22394 }
22395
22396
22397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22398   void * jresult ;
22399   Dali::TypeRegistration *arg1 = 0 ;
22400   std::string *arg2 = 0 ;
22401   Dali::Property::Index arg3 ;
22402   Dali::Property::Type arg4 ;
22403   Dali::AnimatablePropertyRegistration *result = 0 ;
22404
22405   arg1 = (Dali::TypeRegistration *)jarg1;
22406   if (!arg1) {
22407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22408     return 0;
22409   }
22410   if (!jarg2) {
22411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22412     return 0;
22413   }
22414   std::string arg2_str(jarg2);
22415   arg2 = &arg2_str;
22416   arg3 = (Dali::Property::Index)jarg3;
22417   arg4 = (Dali::Property::Type)jarg4;
22418   {
22419     try {
22420       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22421     } catch (std::out_of_range& e) {
22422       {
22423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22424       };
22425     } catch (std::exception& e) {
22426       {
22427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22428       };
22429     } catch (Dali::DaliException e) {
22430       {
22431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22432       };
22433     } catch (...) {
22434       {
22435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22436       };
22437     }
22438   }
22439
22440   jresult = (void *)result;
22441
22442   //argout typemap for const std::string&
22443
22444   return jresult;
22445 }
22446
22447
22448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
22449   void * jresult ;
22450   Dali::TypeRegistration *arg1 = 0 ;
22451   std::string *arg2 = 0 ;
22452   Dali::Property::Index arg3 ;
22453   Dali::Property::Value *arg4 = 0 ;
22454   Dali::AnimatablePropertyRegistration *result = 0 ;
22455
22456   arg1 = (Dali::TypeRegistration *)jarg1;
22457   if (!arg1) {
22458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22459     return 0;
22460   }
22461   if (!jarg2) {
22462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22463     return 0;
22464   }
22465   std::string arg2_str(jarg2);
22466   arg2 = &arg2_str;
22467   arg3 = (Dali::Property::Index)jarg3;
22468   arg4 = (Dali::Property::Value *)jarg4;
22469   if (!arg4) {
22470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
22471     return 0;
22472   }
22473   {
22474     try {
22475       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
22476     } catch (std::out_of_range& e) {
22477       {
22478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22479       };
22480     } catch (std::exception& e) {
22481       {
22482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22483       };
22484     } catch (Dali::DaliException e) {
22485       {
22486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22487       };
22488     } catch (...) {
22489       {
22490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22491       };
22492     }
22493   }
22494
22495   jresult = (void *)result;
22496
22497   //argout typemap for const std::string&
22498
22499   return jresult;
22500 }
22501
22502
22503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
22504   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
22505
22506   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
22507   {
22508     try {
22509       delete arg1;
22510     } catch (std::out_of_range& e) {
22511       {
22512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22513       };
22514     } catch (std::exception& e) {
22515       {
22516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22517       };
22518     } catch (Dali::DaliException e) {
22519       {
22520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22521       };
22522     } catch (...) {
22523       {
22524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22525       };
22526     }
22527   }
22528
22529 }
22530
22531
22532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
22533   void * jresult ;
22534   Dali::TypeRegistration *arg1 = 0 ;
22535   std::string *arg2 = 0 ;
22536   Dali::Property::Index arg3 ;
22537   Dali::Property::Index arg4 ;
22538   unsigned int arg5 ;
22539   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
22540
22541   arg1 = (Dali::TypeRegistration *)jarg1;
22542   if (!arg1) {
22543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22544     return 0;
22545   }
22546   if (!jarg2) {
22547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22548     return 0;
22549   }
22550   std::string arg2_str(jarg2);
22551   arg2 = &arg2_str;
22552   arg3 = (Dali::Property::Index)jarg3;
22553   arg4 = (Dali::Property::Index)jarg4;
22554   arg5 = (unsigned int)jarg5;
22555   {
22556     try {
22557       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
22558     } catch (std::out_of_range& e) {
22559       {
22560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22561       };
22562     } catch (std::exception& e) {
22563       {
22564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22565       };
22566     } catch (Dali::DaliException e) {
22567       {
22568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22569       };
22570     } catch (...) {
22571       {
22572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22573       };
22574     }
22575   }
22576
22577   jresult = (void *)result;
22578
22579   //argout typemap for const std::string&
22580
22581   return jresult;
22582 }
22583
22584
22585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
22586   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
22587
22588   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
22589   {
22590     try {
22591       delete arg1;
22592     } catch (std::out_of_range& e) {
22593       {
22594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22595       };
22596     } catch (std::exception& e) {
22597       {
22598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22599       };
22600     } catch (Dali::DaliException e) {
22601       {
22602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22603       };
22604     } catch (...) {
22605       {
22606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22607       };
22608     }
22609   }
22610
22611 }
22612
22613
22614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22615   void * jresult ;
22616   Dali::TypeRegistration *arg1 = 0 ;
22617   std::string *arg2 = 0 ;
22618   Dali::Property::Index arg3 ;
22619   Dali::Property::Type arg4 ;
22620   Dali::ChildPropertyRegistration *result = 0 ;
22621
22622   arg1 = (Dali::TypeRegistration *)jarg1;
22623   if (!arg1) {
22624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22625     return 0;
22626   }
22627   if (!jarg2) {
22628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22629     return 0;
22630   }
22631   std::string arg2_str(jarg2);
22632   arg2 = &arg2_str;
22633   arg3 = (Dali::Property::Index)jarg3;
22634   arg4 = (Dali::Property::Type)jarg4;
22635   {
22636     try {
22637       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22638     } catch (std::out_of_range& e) {
22639       {
22640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22641       };
22642     } catch (std::exception& e) {
22643       {
22644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22645       };
22646     } catch (Dali::DaliException e) {
22647       {
22648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22649       };
22650     } catch (...) {
22651       {
22652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22653       };
22654     }
22655   }
22656
22657   jresult = (void *)result;
22658
22659   //argout typemap for const std::string&
22660
22661   return jresult;
22662 }
22663
22664
22665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
22666   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
22667
22668   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
22669   {
22670     try {
22671       delete arg1;
22672     } catch (std::out_of_range& e) {
22673       {
22674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22675       };
22676     } catch (std::exception& e) {
22677       {
22678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22679       };
22680     } catch (Dali::DaliException e) {
22681       {
22682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22683       };
22684     } catch (...) {
22685       {
22686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22687       };
22688     }
22689   }
22690
22691 }
22692
22693
22694 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
22695   unsigned int jresult ;
22696   std::string *arg1 = 0 ;
22697   std::type_info *arg2 = 0 ;
22698   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22699   bool result;
22700
22701   if (!jarg1) {
22702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22703     return 0;
22704   }
22705   std::string arg1_str(jarg1);
22706   arg1 = &arg1_str;
22707   arg2 = (std::type_info *)jarg2;
22708   if (!arg2) {
22709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22710     return 0;
22711   }
22712   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
22713   {
22714     try {
22715       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22716     } catch (std::out_of_range& e) {
22717       {
22718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22719       };
22720     } catch (std::exception& e) {
22721       {
22722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22723       };
22724     } catch (Dali::DaliException e) {
22725       {
22726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22727       };
22728     } catch (...) {
22729       {
22730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22731       };
22732     }
22733   }
22734
22735   jresult = result;
22736
22737   //argout typemap for const std::string&
22738
22739   return jresult;
22740 }
22741
22742
22743 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22744   unsigned int jresult ;
22745   std::string *arg1 = 0 ;
22746   std::string *arg2 = 0 ;
22747   Dali::Property::Index arg3 ;
22748   Dali::Property::Type arg4 ;
22749   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22750   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22751   bool result;
22752
22753   if (!jarg1) {
22754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22755     return 0;
22756   }
22757   std::string arg1_str(jarg1);
22758   arg1 = &arg1_str;
22759   if (!jarg2) {
22760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22761     return 0;
22762   }
22763   std::string arg2_str(jarg2);
22764   arg2 = &arg2_str;
22765   arg3 = (Dali::Property::Index)jarg3;
22766   arg4 = (Dali::Property::Type)jarg4;
22767   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22768   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22769   {
22770     try {
22771       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22772     } catch (std::out_of_range& e) {
22773       {
22774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22775       };
22776     } catch (std::exception& e) {
22777       {
22778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22779       };
22780     } catch (Dali::DaliException e) {
22781       {
22782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22783       };
22784     } catch (...) {
22785       {
22786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22787       };
22788     }
22789   }
22790
22791   jresult = result;
22792
22793   //argout typemap for const std::string&
22794
22795
22796   //argout typemap for const std::string&
22797
22798   return jresult;
22799 }
22800
22801
22802 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
22803   float jresult ;
22804   float result;
22805
22806   result = (float)(float)Dali::ParentOrigin::TOP;
22807   jresult = result;
22808   return jresult;
22809 }
22810
22811
22812 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
22813   float jresult ;
22814   float result;
22815
22816   result = (float)(float)Dali::ParentOrigin::BOTTOM;
22817   jresult = result;
22818   return jresult;
22819 }
22820
22821
22822 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
22823   float jresult ;
22824   float result;
22825
22826   result = (float)(float)Dali::ParentOrigin::LEFT;
22827   jresult = result;
22828   return jresult;
22829 }
22830
22831
22832 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
22833   float jresult ;
22834   float result;
22835
22836   result = (float)(float)Dali::ParentOrigin::RIGHT;
22837   jresult = result;
22838   return jresult;
22839 }
22840
22841
22842 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
22843   float jresult ;
22844   float result;
22845
22846   result = (float)(float)Dali::ParentOrigin::MIDDLE;
22847   jresult = result;
22848   return jresult;
22849 }
22850
22851
22852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
22853   void * jresult ;
22854   Dali::Vector3 *result = 0 ;
22855
22856   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
22857   jresult = (void *)result;
22858   return jresult;
22859 }
22860
22861
22862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
22863   void * jresult ;
22864   Dali::Vector3 *result = 0 ;
22865
22866   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
22867   jresult = (void *)result;
22868   return jresult;
22869 }
22870
22871
22872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
22873   void * jresult ;
22874   Dali::Vector3 *result = 0 ;
22875
22876   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
22877   jresult = (void *)result;
22878   return jresult;
22879 }
22880
22881
22882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
22883   void * jresult ;
22884   Dali::Vector3 *result = 0 ;
22885
22886   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
22887   jresult = (void *)result;
22888   return jresult;
22889 }
22890
22891
22892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
22893   void * jresult ;
22894   Dali::Vector3 *result = 0 ;
22895
22896   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
22897   jresult = (void *)result;
22898   return jresult;
22899 }
22900
22901
22902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
22903   void * jresult ;
22904   Dali::Vector3 *result = 0 ;
22905
22906   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
22907   jresult = (void *)result;
22908   return jresult;
22909 }
22910
22911
22912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
22913   void * jresult ;
22914   Dali::Vector3 *result = 0 ;
22915
22916   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
22917   jresult = (void *)result;
22918   return jresult;
22919 }
22920
22921
22922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
22923   void * jresult ;
22924   Dali::Vector3 *result = 0 ;
22925
22926   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
22927   jresult = (void *)result;
22928   return jresult;
22929 }
22930
22931
22932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
22933   void * jresult ;
22934   Dali::Vector3 *result = 0 ;
22935
22936   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
22937   jresult = (void *)result;
22938   return jresult;
22939 }
22940
22941
22942 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
22943   float jresult ;
22944   float result;
22945
22946   result = (float)(float)Dali::AnchorPoint::TOP;
22947   jresult = result;
22948   return jresult;
22949 }
22950
22951
22952 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
22953   float jresult ;
22954   float result;
22955
22956   result = (float)(float)Dali::AnchorPoint::BOTTOM;
22957   jresult = result;
22958   return jresult;
22959 }
22960
22961
22962 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
22963   float jresult ;
22964   float result;
22965
22966   result = (float)(float)Dali::AnchorPoint::LEFT;
22967   jresult = result;
22968   return jresult;
22969 }
22970
22971
22972 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
22973   float jresult ;
22974   float result;
22975
22976   result = (float)(float)Dali::AnchorPoint::RIGHT;
22977   jresult = result;
22978   return jresult;
22979 }
22980
22981
22982 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
22983   float jresult ;
22984   float result;
22985
22986   result = (float)(float)Dali::AnchorPoint::MIDDLE;
22987   jresult = result;
22988   return jresult;
22989 }
22990
22991
22992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
22993   void * jresult ;
22994   Dali::Vector3 *result = 0 ;
22995
22996   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
22997   jresult = (void *)result;
22998   return jresult;
22999 }
23000
23001
23002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
23003   void * jresult ;
23004   Dali::Vector3 *result = 0 ;
23005
23006   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
23007   jresult = (void *)result;
23008   return jresult;
23009 }
23010
23011
23012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
23013   void * jresult ;
23014   Dali::Vector3 *result = 0 ;
23015
23016   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
23017   jresult = (void *)result;
23018   return jresult;
23019 }
23020
23021
23022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
23023   void * jresult ;
23024   Dali::Vector3 *result = 0 ;
23025
23026   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
23027   jresult = (void *)result;
23028   return jresult;
23029 }
23030
23031
23032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
23033   void * jresult ;
23034   Dali::Vector3 *result = 0 ;
23035
23036   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
23037   jresult = (void *)result;
23038   return jresult;
23039 }
23040
23041
23042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
23043   void * jresult ;
23044   Dali::Vector3 *result = 0 ;
23045
23046   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
23047   jresult = (void *)result;
23048   return jresult;
23049 }
23050
23051
23052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
23053   void * jresult ;
23054   Dali::Vector3 *result = 0 ;
23055
23056   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
23057   jresult = (void *)result;
23058   return jresult;
23059 }
23060
23061
23062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
23063   void * jresult ;
23064   Dali::Vector3 *result = 0 ;
23065
23066   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
23067   jresult = (void *)result;
23068   return jresult;
23069 }
23070
23071
23072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
23073   void * jresult ;
23074   Dali::Vector3 *result = 0 ;
23075
23076   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
23077   jresult = (void *)result;
23078   return jresult;
23079 }
23080
23081
23082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
23083   void * jresult ;
23084   Dali::Vector4 *result = 0 ;
23085
23086   result = (Dali::Vector4 *)&Dali::Color::BLACK;
23087   jresult = (void *)result;
23088   return jresult;
23089 }
23090
23091
23092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
23093   void * jresult ;
23094   Dali::Vector4 *result = 0 ;
23095
23096   result = (Dali::Vector4 *)&Dali::Color::WHITE;
23097   jresult = (void *)result;
23098   return jresult;
23099 }
23100
23101
23102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
23103   void * jresult ;
23104   Dali::Vector4 *result = 0 ;
23105
23106   result = (Dali::Vector4 *)&Dali::Color::RED;
23107   jresult = (void *)result;
23108   return jresult;
23109 }
23110
23111
23112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
23113   void * jresult ;
23114   Dali::Vector4 *result = 0 ;
23115
23116   result = (Dali::Vector4 *)&Dali::Color::GREEN;
23117   jresult = (void *)result;
23118   return jresult;
23119 }
23120
23121
23122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
23123   void * jresult ;
23124   Dali::Vector4 *result = 0 ;
23125
23126   result = (Dali::Vector4 *)&Dali::Color::BLUE;
23127   jresult = (void *)result;
23128   return jresult;
23129 }
23130
23131
23132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
23133   void * jresult ;
23134   Dali::Vector4 *result = 0 ;
23135
23136   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
23137   jresult = (void *)result;
23138   return jresult;
23139 }
23140
23141
23142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
23143   void * jresult ;
23144   Dali::Vector4 *result = 0 ;
23145
23146   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
23147   jresult = (void *)result;
23148   return jresult;
23149 }
23150
23151
23152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
23153   void * jresult ;
23154   Dali::Vector4 *result = 0 ;
23155
23156   result = (Dali::Vector4 *)&Dali::Color::CYAN;
23157   jresult = (void *)result;
23158   return jresult;
23159 }
23160
23161
23162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
23163   void * jresult ;
23164   Dali::Vector4 *result = 0 ;
23165
23166   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
23167   jresult = (void *)result;
23168   return jresult;
23169 }
23170
23171
23172 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
23173   float jresult ;
23174   float result;
23175
23176   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
23177   jresult = result;
23178   return jresult;
23179 }
23180
23181
23182 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
23183   float jresult ;
23184   float result;
23185
23186   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
23187   jresult = result;
23188   return jresult;
23189 }
23190
23191
23192 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
23193   float jresult ;
23194   float result;
23195
23196   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
23197   jresult = result;
23198   return jresult;
23199 }
23200
23201
23202 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
23203   float jresult ;
23204   float result;
23205
23206   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
23207   jresult = result;
23208   return jresult;
23209 }
23210
23211
23212 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
23213   float jresult ;
23214   float result;
23215
23216   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
23217   jresult = result;
23218   return jresult;
23219 }
23220
23221
23222 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
23223   float jresult ;
23224   float result;
23225
23226   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
23227   jresult = result;
23228   return jresult;
23229 }
23230
23231
23232 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
23233   float jresult ;
23234   float result;
23235
23236   result = (float)(float)Dali::Math::PI;
23237   jresult = result;
23238   return jresult;
23239 }
23240
23241
23242 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
23243   float jresult ;
23244   float result;
23245
23246   result = (float)(float)Dali::Math::PI_2;
23247   jresult = result;
23248   return jresult;
23249 }
23250
23251
23252 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
23253   float jresult ;
23254   float result;
23255
23256   result = (float)(float)Dali::Math::PI_4;
23257   jresult = result;
23258   return jresult;
23259 }
23260
23261
23262 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
23263   float jresult ;
23264   float result;
23265
23266   result = (float)(float)Dali::Math::PI_OVER_180;
23267   jresult = result;
23268   return jresult;
23269 }
23270
23271
23272 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
23273   float jresult ;
23274   float result;
23275
23276   result = (float)(float)Dali::Math::ONE80_OVER_PI;
23277   jresult = result;
23278   return jresult;
23279 }
23280
23281
23282 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
23283   int jresult ;
23284   Dali::ResizePolicy::Type result;
23285
23286   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
23287   jresult = (int)result;
23288   return jresult;
23289 }
23290
23291
23292 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
23293   unsigned long jresult ;
23294   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23295   Dali::VectorBase::SizeType result;
23296
23297   arg1 = (Dali::VectorBase *)jarg1;
23298   {
23299     try {
23300       result = ((Dali::VectorBase const *)arg1)->Count();
23301     } catch (std::out_of_range& e) {
23302       {
23303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23304       };
23305     } catch (std::exception& e) {
23306       {
23307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23308       };
23309     } catch (Dali::DaliException e) {
23310       {
23311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23312       };
23313     } catch (...) {
23314       {
23315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23316       };
23317     }
23318   }
23319
23320   jresult = (unsigned long)result;
23321   return jresult;
23322 }
23323
23324
23325 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
23326   unsigned long jresult ;
23327   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23328   Dali::VectorBase::SizeType result;
23329
23330   arg1 = (Dali::VectorBase *)jarg1;
23331   {
23332     try {
23333       result = ((Dali::VectorBase const *)arg1)->Size();
23334     } catch (std::out_of_range& e) {
23335       {
23336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23337       };
23338     } catch (std::exception& e) {
23339       {
23340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23341       };
23342     } catch (Dali::DaliException e) {
23343       {
23344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23345       };
23346     } catch (...) {
23347       {
23348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23349       };
23350     }
23351   }
23352
23353   jresult = (unsigned long)result;
23354   return jresult;
23355 }
23356
23357
23358 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
23359   unsigned int jresult ;
23360   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23361   bool result;
23362
23363   arg1 = (Dali::VectorBase *)jarg1;
23364   {
23365     try {
23366       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
23367     } catch (std::out_of_range& e) {
23368       {
23369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23370       };
23371     } catch (std::exception& e) {
23372       {
23373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23374       };
23375     } catch (Dali::DaliException e) {
23376       {
23377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23378       };
23379     } catch (...) {
23380       {
23381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23382       };
23383     }
23384   }
23385
23386   jresult = result;
23387   return jresult;
23388 }
23389
23390
23391 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
23392   unsigned long jresult ;
23393   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23394   Dali::VectorBase::SizeType result;
23395
23396   arg1 = (Dali::VectorBase *)jarg1;
23397   {
23398     try {
23399       result = ((Dali::VectorBase const *)arg1)->Capacity();
23400     } catch (std::out_of_range& e) {
23401       {
23402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23403       };
23404     } catch (std::exception& e) {
23405       {
23406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23407       };
23408     } catch (Dali::DaliException e) {
23409       {
23410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23411       };
23412     } catch (...) {
23413       {
23414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23415       };
23416     }
23417   }
23418
23419   jresult = (unsigned long)result;
23420   return jresult;
23421 }
23422
23423
23424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
23425   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23426
23427   arg1 = (Dali::VectorBase *)jarg1;
23428   {
23429     try {
23430       (arg1)->Release();
23431     } catch (std::out_of_range& e) {
23432       {
23433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23434       };
23435     } catch (std::exception& e) {
23436       {
23437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23438       };
23439     } catch (Dali::DaliException e) {
23440       {
23441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23442       };
23443     } catch (...) {
23444       {
23445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23446       };
23447     }
23448   }
23449
23450 }
23451
23452
23453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
23454   void * jresult ;
23455   Dali::Image *result = 0 ;
23456
23457   {
23458     try {
23459       result = (Dali::Image *)new Dali::Image();
23460     } catch (std::out_of_range& e) {
23461       {
23462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23463       };
23464     } catch (std::exception& e) {
23465       {
23466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23467       };
23468     } catch (Dali::DaliException e) {
23469       {
23470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23471       };
23472     } catch (...) {
23473       {
23474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23475       };
23476     }
23477   }
23478
23479   jresult = (void *)result;
23480   return jresult;
23481 }
23482
23483
23484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
23485   Dali::Image *arg1 = (Dali::Image *) 0 ;
23486
23487   arg1 = (Dali::Image *)jarg1;
23488   {
23489     try {
23490       delete arg1;
23491     } catch (std::out_of_range& e) {
23492       {
23493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23494       };
23495     } catch (std::exception& e) {
23496       {
23497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23498       };
23499     } catch (Dali::DaliException e) {
23500       {
23501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23502       };
23503     } catch (...) {
23504       {
23505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23506       };
23507     }
23508   }
23509
23510 }
23511
23512
23513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
23514   void * jresult ;
23515   Dali::Image *arg1 = 0 ;
23516   Dali::Image *result = 0 ;
23517
23518   arg1 = (Dali::Image *)jarg1;
23519   if (!arg1) {
23520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23521     return 0;
23522   }
23523   {
23524     try {
23525       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
23526     } catch (std::out_of_range& e) {
23527       {
23528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23529       };
23530     } catch (std::exception& e) {
23531       {
23532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23533       };
23534     } catch (Dali::DaliException e) {
23535       {
23536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23537       };
23538     } catch (...) {
23539       {
23540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23541       };
23542     }
23543   }
23544
23545   jresult = (void *)result;
23546   return jresult;
23547 }
23548
23549
23550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
23551   void * jresult ;
23552   Dali::Image *arg1 = (Dali::Image *) 0 ;
23553   Dali::Image *arg2 = 0 ;
23554   Dali::Image *result = 0 ;
23555
23556   arg1 = (Dali::Image *)jarg1;
23557   arg2 = (Dali::Image *)jarg2;
23558   if (!arg2) {
23559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23560     return 0;
23561   }
23562   {
23563     try {
23564       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
23565     } catch (std::out_of_range& e) {
23566       {
23567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23568       };
23569     } catch (std::exception& e) {
23570       {
23571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23572       };
23573     } catch (Dali::DaliException e) {
23574       {
23575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23576       };
23577     } catch (...) {
23578       {
23579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23580       };
23581     }
23582   }
23583
23584   jresult = (void *)result;
23585   return jresult;
23586 }
23587
23588
23589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
23590   void * jresult ;
23591   Dali::BaseHandle arg1 ;
23592   Dali::BaseHandle *argp1 ;
23593   Dali::Image result;
23594
23595   argp1 = (Dali::BaseHandle *)jarg1;
23596   if (!argp1) {
23597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23598     return 0;
23599   }
23600   arg1 = *argp1;
23601   {
23602     try {
23603       result = Dali::Image::DownCast(arg1);
23604     } catch (std::out_of_range& e) {
23605       {
23606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23607       };
23608     } catch (std::exception& e) {
23609       {
23610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23611       };
23612     } catch (Dali::DaliException e) {
23613       {
23614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23615       };
23616     } catch (...) {
23617       {
23618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23619       };
23620     }
23621   }
23622
23623   jresult = new Dali::Image((const Dali::Image &)result);
23624   return jresult;
23625 }
23626
23627
23628 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
23629   unsigned int jresult ;
23630   Dali::Image *arg1 = (Dali::Image *) 0 ;
23631   unsigned int result;
23632
23633   arg1 = (Dali::Image *)jarg1;
23634   {
23635     try {
23636       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
23637     } catch (std::out_of_range& e) {
23638       {
23639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23640       };
23641     } catch (std::exception& e) {
23642       {
23643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23644       };
23645     } catch (Dali::DaliException e) {
23646       {
23647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23648       };
23649     } catch (...) {
23650       {
23651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23652       };
23653     }
23654   }
23655
23656   jresult = result;
23657   return jresult;
23658 }
23659
23660
23661 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
23662   unsigned int jresult ;
23663   Dali::Image *arg1 = (Dali::Image *) 0 ;
23664   unsigned int result;
23665
23666   arg1 = (Dali::Image *)jarg1;
23667   {
23668     try {
23669       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
23670     } catch (std::out_of_range& e) {
23671       {
23672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23673       };
23674     } catch (std::exception& e) {
23675       {
23676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23677       };
23678     } catch (Dali::DaliException e) {
23679       {
23680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23681       };
23682     } catch (...) {
23683       {
23684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23685       };
23686     }
23687   }
23688
23689   jresult = result;
23690   return jresult;
23691 }
23692
23693
23694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
23695   void * jresult ;
23696   Dali::Image *arg1 = (Dali::Image *) 0 ;
23697   Dali::Image::ImageSignalType *result = 0 ;
23698
23699   arg1 = (Dali::Image *)jarg1;
23700   {
23701     try {
23702       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
23703     } catch (std::out_of_range& e) {
23704       {
23705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23706       };
23707     } catch (std::exception& e) {
23708       {
23709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23710       };
23711     } catch (Dali::DaliException e) {
23712       {
23713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23714       };
23715     } catch (...) {
23716       {
23717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23718       };
23719     }
23720   }
23721
23722   jresult = (void *)result;
23723   return jresult;
23724 }
23725
23726
23727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
23728   int jresult ;
23729   Dali::Pixel::Format result;
23730
23731   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
23732   jresult = (int)result;
23733   return jresult;
23734 }
23735
23736
23737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
23738   int jresult ;
23739   Dali::Pixel::Format result;
23740
23741   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
23742   jresult = (int)result;
23743   return jresult;
23744 }
23745
23746
23747 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
23748   unsigned int jresult ;
23749   Dali::Pixel::Format arg1 ;
23750   bool result;
23751
23752   arg1 = (Dali::Pixel::Format)jarg1;
23753   {
23754     try {
23755       result = (bool)Dali::Pixel::HasAlpha(arg1);
23756     } catch (std::out_of_range& e) {
23757       {
23758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23759       };
23760     } catch (std::exception& e) {
23761       {
23762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23763       };
23764     } catch (Dali::DaliException e) {
23765       {
23766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23767       };
23768     } catch (...) {
23769       {
23770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23771       };
23772     }
23773   }
23774
23775   jresult = result;
23776   return jresult;
23777 }
23778
23779
23780 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
23781   unsigned int jresult ;
23782   Dali::Pixel::Format arg1 ;
23783   unsigned int result;
23784
23785   arg1 = (Dali::Pixel::Format)jarg1;
23786   {
23787     try {
23788       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
23789     } catch (std::out_of_range& e) {
23790       {
23791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23792       };
23793     } catch (std::exception& e) {
23794       {
23795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23796       };
23797     } catch (Dali::DaliException e) {
23798       {
23799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23800       };
23801     } catch (...) {
23802       {
23803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23804       };
23805     }
23806   }
23807
23808   jresult = result;
23809   return jresult;
23810 }
23811
23812
23813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
23814   Dali::Pixel::Format arg1 ;
23815   int *arg2 = 0 ;
23816   int *arg3 = 0 ;
23817
23818   arg1 = (Dali::Pixel::Format)jarg1;
23819   arg2 = (int *)jarg2;
23820   if (!arg2) {
23821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23822     return ;
23823   }
23824   arg3 = (int *)jarg3;
23825   if (!arg3) {
23826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23827     return ;
23828   }
23829   {
23830     try {
23831       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
23832     } catch (std::out_of_range& e) {
23833       {
23834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23835       };
23836     } catch (std::exception& e) {
23837       {
23838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23839       };
23840     } catch (Dali::DaliException e) {
23841       {
23842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23843       };
23844     } catch (...) {
23845       {
23846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23847       };
23848     }
23849   }
23850
23851 }
23852
23853
23854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
23855   void * jresult ;
23856   unsigned char *arg1 = (unsigned char *) 0 ;
23857   unsigned int arg2 ;
23858   unsigned int arg3 ;
23859   unsigned int arg4 ;
23860   Dali::Pixel::Format arg5 ;
23861   Dali::PixelData::ReleaseFunction arg6 ;
23862   Dali::PixelData result;
23863
23864   arg1 = jarg1;
23865   arg2 = (unsigned int)jarg2;
23866   arg3 = (unsigned int)jarg3;
23867   arg4 = (unsigned int)jarg4;
23868   arg5 = (Dali::Pixel::Format)jarg5;
23869   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
23870   {
23871     try {
23872       result = Dali::PixelData::New(arg1,arg2,arg3,arg4,arg5,arg6);
23873     } catch (std::out_of_range& e) {
23874       {
23875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23876       };
23877     } catch (std::exception& e) {
23878       {
23879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23880       };
23881     } catch (Dali::DaliException e) {
23882       {
23883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23884       };
23885     } catch (...) {
23886       {
23887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23888       };
23889     }
23890   }
23891
23892   jresult = new Dali::PixelData((const Dali::PixelData &)result);
23893
23894
23895   return jresult;
23896 }
23897
23898
23899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
23900   void * jresult ;
23901   Dali::PixelData *result = 0 ;
23902
23903   {
23904     try {
23905       result = (Dali::PixelData *)new Dali::PixelData();
23906     } catch (std::out_of_range& e) {
23907       {
23908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23909       };
23910     } catch (std::exception& e) {
23911       {
23912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23913       };
23914     } catch (Dali::DaliException e) {
23915       {
23916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23917       };
23918     } catch (...) {
23919       {
23920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23921       };
23922     }
23923   }
23924
23925   jresult = (void *)result;
23926   return jresult;
23927 }
23928
23929
23930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
23931   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23932
23933   arg1 = (Dali::PixelData *)jarg1;
23934   {
23935     try {
23936       delete arg1;
23937     } catch (std::out_of_range& e) {
23938       {
23939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23940       };
23941     } catch (std::exception& e) {
23942       {
23943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23944       };
23945     } catch (Dali::DaliException e) {
23946       {
23947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23948       };
23949     } catch (...) {
23950       {
23951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23952       };
23953     }
23954   }
23955
23956 }
23957
23958
23959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
23960   void * jresult ;
23961   Dali::PixelData *arg1 = 0 ;
23962   Dali::PixelData *result = 0 ;
23963
23964   arg1 = (Dali::PixelData *)jarg1;
23965   if (!arg1) {
23966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
23967     return 0;
23968   }
23969   {
23970     try {
23971       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
23972     } catch (std::out_of_range& e) {
23973       {
23974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23975       };
23976     } catch (std::exception& e) {
23977       {
23978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23979       };
23980     } catch (Dali::DaliException e) {
23981       {
23982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23983       };
23984     } catch (...) {
23985       {
23986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23987       };
23988     }
23989   }
23990
23991   jresult = (void *)result;
23992   return jresult;
23993 }
23994
23995
23996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
23997   void * jresult ;
23998   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23999   Dali::PixelData *arg2 = 0 ;
24000   Dali::PixelData *result = 0 ;
24001
24002   arg1 = (Dali::PixelData *)jarg1;
24003   arg2 = (Dali::PixelData *)jarg2;
24004   if (!arg2) {
24005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24006     return 0;
24007   }
24008   {
24009     try {
24010       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
24011     } catch (std::out_of_range& e) {
24012       {
24013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24014       };
24015     } catch (std::exception& e) {
24016       {
24017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24018       };
24019     } catch (Dali::DaliException e) {
24020       {
24021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24022       };
24023     } catch (...) {
24024       {
24025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24026       };
24027     }
24028   }
24029
24030   jresult = (void *)result;
24031   return jresult;
24032 }
24033
24034
24035 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
24036   unsigned int jresult ;
24037   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24038   unsigned int result;
24039
24040   arg1 = (Dali::PixelData *)jarg1;
24041   {
24042     try {
24043       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
24044     } catch (std::out_of_range& e) {
24045       {
24046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24047       };
24048     } catch (std::exception& e) {
24049       {
24050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24051       };
24052     } catch (Dali::DaliException e) {
24053       {
24054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24055       };
24056     } catch (...) {
24057       {
24058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24059       };
24060     }
24061   }
24062
24063   jresult = result;
24064   return jresult;
24065 }
24066
24067
24068 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
24069   unsigned int jresult ;
24070   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24071   unsigned int result;
24072
24073   arg1 = (Dali::PixelData *)jarg1;
24074   {
24075     try {
24076       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
24077     } catch (std::out_of_range& e) {
24078       {
24079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24080       };
24081     } catch (std::exception& e) {
24082       {
24083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24084       };
24085     } catch (Dali::DaliException e) {
24086       {
24087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24088       };
24089     } catch (...) {
24090       {
24091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24092       };
24093     }
24094   }
24095
24096   jresult = result;
24097   return jresult;
24098 }
24099
24100
24101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
24102   int jresult ;
24103   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24104   Dali::Pixel::Format result;
24105
24106   arg1 = (Dali::PixelData *)jarg1;
24107   {
24108     try {
24109       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
24110     } catch (std::out_of_range& e) {
24111       {
24112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24113       };
24114     } catch (std::exception& e) {
24115       {
24116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24117       };
24118     } catch (Dali::DaliException e) {
24119       {
24120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24121       };
24122     } catch (...) {
24123       {
24124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24125       };
24126     }
24127   }
24128
24129   jresult = (int)result;
24130   return jresult;
24131 }
24132
24133
24134 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
24135   unsigned int jresult ;
24136   unsigned int result;
24137
24138   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
24139   jresult = result;
24140   return jresult;
24141 }
24142
24143
24144 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
24145   unsigned int jresult ;
24146   unsigned int result;
24147
24148   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
24149   jresult = result;
24150   return jresult;
24151 }
24152
24153
24154 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
24155   unsigned int jresult ;
24156   unsigned int result;
24157
24158   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
24159   jresult = result;
24160   return jresult;
24161 }
24162
24163
24164 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
24165   unsigned int jresult ;
24166   unsigned int result;
24167
24168   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
24169   jresult = result;
24170   return jresult;
24171 }
24172
24173
24174 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
24175   unsigned int jresult ;
24176   unsigned int result;
24177
24178   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
24179   jresult = result;
24180   return jresult;
24181 }
24182
24183
24184 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
24185   unsigned int jresult ;
24186   unsigned int result;
24187
24188   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
24189   jresult = result;
24190   return jresult;
24191 }
24192
24193
24194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
24195   void * jresult ;
24196   Dali::TextureType::Type arg1 ;
24197   Dali::Pixel::Format arg2 ;
24198   unsigned int arg3 ;
24199   unsigned int arg4 ;
24200   Dali::Texture result;
24201
24202   arg1 = (Dali::TextureType::Type)jarg1;
24203   arg2 = (Dali::Pixel::Format)jarg2;
24204   arg3 = (unsigned int)jarg3;
24205   arg4 = (unsigned int)jarg4;
24206   {
24207     try {
24208       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
24209     } catch (std::out_of_range& e) {
24210       {
24211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24212       };
24213     } catch (std::exception& e) {
24214       {
24215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24216       };
24217     } catch (Dali::DaliException e) {
24218       {
24219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24220       };
24221     } catch (...) {
24222       {
24223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24224       };
24225     }
24226   }
24227
24228   jresult = new Dali::Texture((const Dali::Texture &)result);
24229   return jresult;
24230 }
24231
24232
24233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
24234   void * jresult ;
24235   NativeImageInterface *arg1 = 0 ;
24236   Dali::Texture result;
24237
24238   arg1 = (NativeImageInterface *)jarg1;
24239   if (!arg1) {
24240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
24241     return 0;
24242   }
24243   {
24244     try {
24245       result = Dali::Texture::New(*arg1);
24246     } catch (std::out_of_range& e) {
24247       {
24248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24249       };
24250     } catch (std::exception& e) {
24251       {
24252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24253       };
24254     } catch (Dali::DaliException e) {
24255       {
24256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24257       };
24258     } catch (...) {
24259       {
24260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24261       };
24262     }
24263   }
24264
24265   jresult = new Dali::Texture((const Dali::Texture &)result);
24266   return jresult;
24267 }
24268
24269
24270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
24271   void * jresult ;
24272   Dali::Texture *result = 0 ;
24273
24274   {
24275     try {
24276       result = (Dali::Texture *)new Dali::Texture();
24277     } catch (std::out_of_range& e) {
24278       {
24279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24280       };
24281     } catch (std::exception& e) {
24282       {
24283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24284       };
24285     } catch (Dali::DaliException e) {
24286       {
24287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24288       };
24289     } catch (...) {
24290       {
24291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24292       };
24293     }
24294   }
24295
24296   jresult = (void *)result;
24297   return jresult;
24298 }
24299
24300
24301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
24302   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24303
24304   arg1 = (Dali::Texture *)jarg1;
24305   {
24306     try {
24307       delete arg1;
24308     } catch (std::out_of_range& e) {
24309       {
24310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24311       };
24312     } catch (std::exception& e) {
24313       {
24314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24315       };
24316     } catch (Dali::DaliException e) {
24317       {
24318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24319       };
24320     } catch (...) {
24321       {
24322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24323       };
24324     }
24325   }
24326
24327 }
24328
24329
24330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
24331   void * jresult ;
24332   Dali::Texture *arg1 = 0 ;
24333   Dali::Texture *result = 0 ;
24334
24335   arg1 = (Dali::Texture *)jarg1;
24336   if (!arg1) {
24337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24338     return 0;
24339   }
24340   {
24341     try {
24342       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
24343     } catch (std::out_of_range& e) {
24344       {
24345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24346       };
24347     } catch (std::exception& e) {
24348       {
24349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24350       };
24351     } catch (Dali::DaliException e) {
24352       {
24353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24354       };
24355     } catch (...) {
24356       {
24357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24358       };
24359     }
24360   }
24361
24362   jresult = (void *)result;
24363   return jresult;
24364 }
24365
24366
24367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
24368   void * jresult ;
24369   Dali::BaseHandle arg1 ;
24370   Dali::BaseHandle *argp1 ;
24371   Dali::Texture result;
24372
24373   argp1 = (Dali::BaseHandle *)jarg1;
24374   if (!argp1) {
24375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24376     return 0;
24377   }
24378   arg1 = *argp1;
24379   {
24380     try {
24381       result = Dali::Texture::DownCast(arg1);
24382     } catch (std::out_of_range& e) {
24383       {
24384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24385       };
24386     } catch (std::exception& e) {
24387       {
24388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24389       };
24390     } catch (Dali::DaliException e) {
24391       {
24392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24393       };
24394     } catch (...) {
24395       {
24396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24397       };
24398     }
24399   }
24400
24401   jresult = new Dali::Texture((const Dali::Texture &)result);
24402   return jresult;
24403 }
24404
24405
24406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
24407   void * jresult ;
24408   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24409   Dali::Texture *arg2 = 0 ;
24410   Dali::Texture *result = 0 ;
24411
24412   arg1 = (Dali::Texture *)jarg1;
24413   arg2 = (Dali::Texture *)jarg2;
24414   if (!arg2) {
24415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24416     return 0;
24417   }
24418   {
24419     try {
24420       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
24421     } catch (std::out_of_range& e) {
24422       {
24423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24424       };
24425     } catch (std::exception& e) {
24426       {
24427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24428       };
24429     } catch (Dali::DaliException e) {
24430       {
24431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24432       };
24433     } catch (...) {
24434       {
24435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24436       };
24437     }
24438   }
24439
24440   jresult = (void *)result;
24441   return jresult;
24442 }
24443
24444
24445 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
24446   unsigned int jresult ;
24447   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24448   Dali::PixelData arg2 ;
24449   Dali::PixelData *argp2 ;
24450   bool result;
24451
24452   arg1 = (Dali::Texture *)jarg1;
24453   argp2 = (Dali::PixelData *)jarg2;
24454   if (!argp2) {
24455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24456     return 0;
24457   }
24458   arg2 = *argp2;
24459   {
24460     try {
24461       result = (bool)(arg1)->Upload(arg2);
24462     } catch (std::out_of_range& e) {
24463       {
24464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24465       };
24466     } catch (std::exception& e) {
24467       {
24468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24469       };
24470     } catch (Dali::DaliException e) {
24471       {
24472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24473       };
24474     } catch (...) {
24475       {
24476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24477       };
24478     }
24479   }
24480
24481   jresult = result;
24482   return jresult;
24483 }
24484
24485
24486 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) {
24487   unsigned int jresult ;
24488   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24489   Dali::PixelData arg2 ;
24490   unsigned int arg3 ;
24491   unsigned int arg4 ;
24492   unsigned int arg5 ;
24493   unsigned int arg6 ;
24494   unsigned int arg7 ;
24495   unsigned int arg8 ;
24496   Dali::PixelData *argp2 ;
24497   bool result;
24498
24499   arg1 = (Dali::Texture *)jarg1;
24500   argp2 = (Dali::PixelData *)jarg2;
24501   if (!argp2) {
24502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24503     return 0;
24504   }
24505   arg2 = *argp2;
24506   arg3 = (unsigned int)jarg3;
24507   arg4 = (unsigned int)jarg4;
24508   arg5 = (unsigned int)jarg5;
24509   arg6 = (unsigned int)jarg6;
24510   arg7 = (unsigned int)jarg7;
24511   arg8 = (unsigned int)jarg8;
24512   {
24513     try {
24514       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24515     } catch (std::out_of_range& e) {
24516       {
24517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24518       };
24519     } catch (std::exception& e) {
24520       {
24521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24522       };
24523     } catch (Dali::DaliException e) {
24524       {
24525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24526       };
24527     } catch (...) {
24528       {
24529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24530       };
24531     }
24532   }
24533
24534   jresult = result;
24535   return jresult;
24536 }
24537
24538
24539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
24540   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24541
24542   arg1 = (Dali::Texture *)jarg1;
24543   {
24544     try {
24545       (arg1)->GenerateMipmaps();
24546     } catch (std::out_of_range& e) {
24547       {
24548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24549       };
24550     } catch (std::exception& e) {
24551       {
24552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24553       };
24554     } catch (Dali::DaliException e) {
24555       {
24556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24557       };
24558     } catch (...) {
24559       {
24560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24561       };
24562     }
24563   }
24564
24565 }
24566
24567
24568 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
24569   unsigned int jresult ;
24570   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24571   unsigned int result;
24572
24573   arg1 = (Dali::Texture *)jarg1;
24574   {
24575     try {
24576       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
24577     } catch (std::out_of_range& e) {
24578       {
24579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24580       };
24581     } catch (std::exception& e) {
24582       {
24583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24584       };
24585     } catch (Dali::DaliException e) {
24586       {
24587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24588       };
24589     } catch (...) {
24590       {
24591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24592       };
24593     }
24594   }
24595
24596   jresult = result;
24597   return jresult;
24598 }
24599
24600
24601 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
24602   unsigned int jresult ;
24603   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24604   unsigned int result;
24605
24606   arg1 = (Dali::Texture *)jarg1;
24607   {
24608     try {
24609       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
24610     } catch (std::out_of_range& e) {
24611       {
24612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24613       };
24614     } catch (std::exception& e) {
24615       {
24616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24617       };
24618     } catch (Dali::DaliException e) {
24619       {
24620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24621       };
24622     } catch (...) {
24623       {
24624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24625       };
24626     }
24627   }
24628
24629   jresult = result;
24630   return jresult;
24631 }
24632
24633
24634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_2(void * jarg1) {
24635   void * jresult ;
24636   Dali::Internal::Texture *arg1 = (Dali::Internal::Texture *) 0 ;
24637   Dali::Texture *result = 0 ;
24638
24639   arg1 = (Dali::Internal::Texture *)jarg1;
24640   {
24641     try {
24642       result = (Dali::Texture *)new Dali::Texture(arg1);
24643     } catch (std::out_of_range& e) {
24644       {
24645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24646       };
24647     } catch (std::exception& e) {
24648       {
24649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24650       };
24651     } catch (Dali::DaliException e) {
24652       {
24653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24654       };
24655     } catch (...) {
24656       {
24657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24658       };
24659     }
24660   }
24661
24662   jresult = (void *)result;
24663   return jresult;
24664 }
24665
24666
24667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
24668   void * jresult ;
24669   Dali::Sampler result;
24670
24671   {
24672     try {
24673       result = Dali::Sampler::New();
24674     } catch (std::out_of_range& e) {
24675       {
24676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24677       };
24678     } catch (std::exception& e) {
24679       {
24680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24681       };
24682     } catch (Dali::DaliException e) {
24683       {
24684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24685       };
24686     } catch (...) {
24687       {
24688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24689       };
24690     }
24691   }
24692
24693   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24694   return jresult;
24695 }
24696
24697
24698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
24699   void * jresult ;
24700   Dali::Sampler *result = 0 ;
24701
24702   {
24703     try {
24704       result = (Dali::Sampler *)new Dali::Sampler();
24705     } catch (std::out_of_range& e) {
24706       {
24707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24708       };
24709     } catch (std::exception& e) {
24710       {
24711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24712       };
24713     } catch (Dali::DaliException e) {
24714       {
24715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24716       };
24717     } catch (...) {
24718       {
24719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24720       };
24721     }
24722   }
24723
24724   jresult = (void *)result;
24725   return jresult;
24726 }
24727
24728
24729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
24730   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24731
24732   arg1 = (Dali::Sampler *)jarg1;
24733   {
24734     try {
24735       delete arg1;
24736     } catch (std::out_of_range& e) {
24737       {
24738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24739       };
24740     } catch (std::exception& e) {
24741       {
24742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24743       };
24744     } catch (Dali::DaliException e) {
24745       {
24746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24747       };
24748     } catch (...) {
24749       {
24750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24751       };
24752     }
24753   }
24754
24755 }
24756
24757
24758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
24759   void * jresult ;
24760   Dali::Sampler *arg1 = 0 ;
24761   Dali::Sampler *result = 0 ;
24762
24763   arg1 = (Dali::Sampler *)jarg1;
24764   if (!arg1) {
24765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24766     return 0;
24767   }
24768   {
24769     try {
24770       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
24771     } catch (std::out_of_range& e) {
24772       {
24773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24774       };
24775     } catch (std::exception& e) {
24776       {
24777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24778       };
24779     } catch (Dali::DaliException e) {
24780       {
24781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24782       };
24783     } catch (...) {
24784       {
24785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24786       };
24787     }
24788   }
24789
24790   jresult = (void *)result;
24791   return jresult;
24792 }
24793
24794
24795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
24796   void * jresult ;
24797   Dali::BaseHandle arg1 ;
24798   Dali::BaseHandle *argp1 ;
24799   Dali::Sampler result;
24800
24801   argp1 = (Dali::BaseHandle *)jarg1;
24802   if (!argp1) {
24803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24804     return 0;
24805   }
24806   arg1 = *argp1;
24807   {
24808     try {
24809       result = Dali::Sampler::DownCast(arg1);
24810     } catch (std::out_of_range& e) {
24811       {
24812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24813       };
24814     } catch (std::exception& e) {
24815       {
24816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24817       };
24818     } catch (Dali::DaliException e) {
24819       {
24820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24821       };
24822     } catch (...) {
24823       {
24824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24825       };
24826     }
24827   }
24828
24829   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24830   return jresult;
24831 }
24832
24833
24834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
24835   void * jresult ;
24836   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24837   Dali::Sampler *arg2 = 0 ;
24838   Dali::Sampler *result = 0 ;
24839
24840   arg1 = (Dali::Sampler *)jarg1;
24841   arg2 = (Dali::Sampler *)jarg2;
24842   if (!arg2) {
24843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24844     return 0;
24845   }
24846   {
24847     try {
24848       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
24849     } catch (std::out_of_range& e) {
24850       {
24851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24852       };
24853     } catch (std::exception& e) {
24854       {
24855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24856       };
24857     } catch (Dali::DaliException e) {
24858       {
24859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24860       };
24861     } catch (...) {
24862       {
24863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24864       };
24865     }
24866   }
24867
24868   jresult = (void *)result;
24869   return jresult;
24870 }
24871
24872
24873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
24874   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24875   Dali::FilterMode::Type arg2 ;
24876   Dali::FilterMode::Type arg3 ;
24877
24878   arg1 = (Dali::Sampler *)jarg1;
24879   arg2 = (Dali::FilterMode::Type)jarg2;
24880   arg3 = (Dali::FilterMode::Type)jarg3;
24881   {
24882     try {
24883       (arg1)->SetFilterMode(arg2,arg3);
24884     } catch (std::out_of_range& e) {
24885       {
24886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24887       };
24888     } catch (std::exception& e) {
24889       {
24890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24891       };
24892     } catch (Dali::DaliException e) {
24893       {
24894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24895       };
24896     } catch (...) {
24897       {
24898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24899       };
24900     }
24901   }
24902
24903 }
24904
24905
24906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
24907   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24908   Dali::WrapMode::Type arg2 ;
24909   Dali::WrapMode::Type arg3 ;
24910
24911   arg1 = (Dali::Sampler *)jarg1;
24912   arg2 = (Dali::WrapMode::Type)jarg2;
24913   arg3 = (Dali::WrapMode::Type)jarg3;
24914   {
24915     try {
24916       (arg1)->SetWrapMode(arg2,arg3);
24917     } catch (std::out_of_range& e) {
24918       {
24919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24920       };
24921     } catch (std::exception& e) {
24922       {
24923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24924       };
24925     } catch (Dali::DaliException e) {
24926       {
24927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24928       };
24929     } catch (...) {
24930       {
24931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24932       };
24933     }
24934   }
24935
24936 }
24937
24938
24939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
24940   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24941   Dali::WrapMode::Type arg2 ;
24942   Dali::WrapMode::Type arg3 ;
24943   Dali::WrapMode::Type arg4 ;
24944
24945   arg1 = (Dali::Sampler *)jarg1;
24946   arg2 = (Dali::WrapMode::Type)jarg2;
24947   arg3 = (Dali::WrapMode::Type)jarg3;
24948   arg4 = (Dali::WrapMode::Type)jarg4;
24949   {
24950     try {
24951       (arg1)->SetWrapMode(arg2,arg3,arg4);
24952     } catch (std::out_of_range& e) {
24953       {
24954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24955       };
24956     } catch (std::exception& e) {
24957       {
24958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24959       };
24960     } catch (Dali::DaliException e) {
24961       {
24962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24963       };
24964     } catch (...) {
24965       {
24966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24967       };
24968     }
24969   }
24970
24971 }
24972
24973
24974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
24975   void * jresult ;
24976   Dali::TextureSet result;
24977
24978   {
24979     try {
24980       result = Dali::TextureSet::New();
24981     } catch (std::out_of_range& e) {
24982       {
24983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24984       };
24985     } catch (std::exception& e) {
24986       {
24987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24988       };
24989     } catch (Dali::DaliException e) {
24990       {
24991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24992       };
24993     } catch (...) {
24994       {
24995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24996       };
24997     }
24998   }
24999
25000   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25001   return jresult;
25002 }
25003
25004
25005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
25006   void * jresult ;
25007   Dali::TextureSet *result = 0 ;
25008
25009   {
25010     try {
25011       result = (Dali::TextureSet *)new Dali::TextureSet();
25012     } catch (std::out_of_range& e) {
25013       {
25014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25015       };
25016     } catch (std::exception& e) {
25017       {
25018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25019       };
25020     } catch (Dali::DaliException e) {
25021       {
25022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25023       };
25024     } catch (...) {
25025       {
25026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25027       };
25028     }
25029   }
25030
25031   jresult = (void *)result;
25032   return jresult;
25033 }
25034
25035
25036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
25037   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25038
25039   arg1 = (Dali::TextureSet *)jarg1;
25040   {
25041     try {
25042       delete arg1;
25043     } catch (std::out_of_range& e) {
25044       {
25045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25046       };
25047     } catch (std::exception& e) {
25048       {
25049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25050       };
25051     } catch (Dali::DaliException e) {
25052       {
25053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25054       };
25055     } catch (...) {
25056       {
25057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25058       };
25059     }
25060   }
25061
25062 }
25063
25064
25065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
25066   void * jresult ;
25067   Dali::TextureSet *arg1 = 0 ;
25068   Dali::TextureSet *result = 0 ;
25069
25070   arg1 = (Dali::TextureSet *)jarg1;
25071   if (!arg1) {
25072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25073     return 0;
25074   }
25075   {
25076     try {
25077       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
25078     } catch (std::out_of_range& e) {
25079       {
25080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25081       };
25082     } catch (std::exception& e) {
25083       {
25084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25085       };
25086     } catch (Dali::DaliException e) {
25087       {
25088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25089       };
25090     } catch (...) {
25091       {
25092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25093       };
25094     }
25095   }
25096
25097   jresult = (void *)result;
25098   return jresult;
25099 }
25100
25101
25102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
25103   void * jresult ;
25104   Dali::BaseHandle arg1 ;
25105   Dali::BaseHandle *argp1 ;
25106   Dali::TextureSet result;
25107
25108   argp1 = (Dali::BaseHandle *)jarg1;
25109   if (!argp1) {
25110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25111     return 0;
25112   }
25113   arg1 = *argp1;
25114   {
25115     try {
25116       result = Dali::TextureSet::DownCast(arg1);
25117     } catch (std::out_of_range& e) {
25118       {
25119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25120       };
25121     } catch (std::exception& e) {
25122       {
25123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25124       };
25125     } catch (Dali::DaliException e) {
25126       {
25127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25128       };
25129     } catch (...) {
25130       {
25131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25132       };
25133     }
25134   }
25135
25136   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25137   return jresult;
25138 }
25139
25140
25141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
25142   void * jresult ;
25143   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25144   Dali::TextureSet *arg2 = 0 ;
25145   Dali::TextureSet *result = 0 ;
25146
25147   arg1 = (Dali::TextureSet *)jarg1;
25148   arg2 = (Dali::TextureSet *)jarg2;
25149   if (!arg2) {
25150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25151     return 0;
25152   }
25153   {
25154     try {
25155       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
25156     } catch (std::out_of_range& e) {
25157       {
25158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25159       };
25160     } catch (std::exception& e) {
25161       {
25162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25163       };
25164     } catch (Dali::DaliException e) {
25165       {
25166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25167       };
25168     } catch (...) {
25169       {
25170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25171       };
25172     }
25173   }
25174
25175   jresult = (void *)result;
25176   return jresult;
25177 }
25178
25179
25180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
25181   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25182   size_t arg2 ;
25183   Dali::Texture arg3 ;
25184   Dali::Texture *argp3 ;
25185
25186   arg1 = (Dali::TextureSet *)jarg1;
25187   arg2 = (size_t)jarg2;
25188   argp3 = (Dali::Texture *)jarg3;
25189   if (!argp3) {
25190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
25191     return ;
25192   }
25193   arg3 = *argp3;
25194   {
25195     try {
25196       (arg1)->SetTexture(arg2,arg3);
25197     } catch (std::out_of_range& e) {
25198       {
25199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25200       };
25201     } catch (std::exception& e) {
25202       {
25203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25204       };
25205     } catch (Dali::DaliException e) {
25206       {
25207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25208       };
25209     } catch (...) {
25210       {
25211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25212       };
25213     }
25214   }
25215
25216 }
25217
25218
25219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
25220   void * jresult ;
25221   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25222   size_t arg2 ;
25223   Dali::Texture result;
25224
25225   arg1 = (Dali::TextureSet *)jarg1;
25226   arg2 = (size_t)jarg2;
25227   {
25228     try {
25229       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
25230     } catch (std::out_of_range& e) {
25231       {
25232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25233       };
25234     } catch (std::exception& e) {
25235       {
25236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25237       };
25238     } catch (Dali::DaliException e) {
25239       {
25240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25241       };
25242     } catch (...) {
25243       {
25244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25245       };
25246     }
25247   }
25248
25249   jresult = new Dali::Texture((const Dali::Texture &)result);
25250   return jresult;
25251 }
25252
25253
25254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
25255   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25256   size_t arg2 ;
25257   Dali::Sampler arg3 ;
25258   Dali::Sampler *argp3 ;
25259
25260   arg1 = (Dali::TextureSet *)jarg1;
25261   arg2 = (size_t)jarg2;
25262   argp3 = (Dali::Sampler *)jarg3;
25263   if (!argp3) {
25264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
25265     return ;
25266   }
25267   arg3 = *argp3;
25268   {
25269     try {
25270       (arg1)->SetSampler(arg2,arg3);
25271     } catch (std::out_of_range& e) {
25272       {
25273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25274       };
25275     } catch (std::exception& e) {
25276       {
25277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25278       };
25279     } catch (Dali::DaliException e) {
25280       {
25281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25282       };
25283     } catch (...) {
25284       {
25285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25286       };
25287     }
25288   }
25289
25290 }
25291
25292
25293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
25294   void * jresult ;
25295   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25296   size_t arg2 ;
25297   Dali::Sampler result;
25298
25299   arg1 = (Dali::TextureSet *)jarg1;
25300   arg2 = (size_t)jarg2;
25301   {
25302     try {
25303       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
25304     } catch (std::out_of_range& e) {
25305       {
25306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25307       };
25308     } catch (std::exception& e) {
25309       {
25310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25311       };
25312     } catch (Dali::DaliException e) {
25313       {
25314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25315       };
25316     } catch (...) {
25317       {
25318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25319       };
25320     }
25321   }
25322
25323   jresult = new Dali::Sampler((const Dali::Sampler &)result);
25324   return jresult;
25325 }
25326
25327
25328 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
25329   unsigned long jresult ;
25330   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25331   size_t result;
25332
25333   arg1 = (Dali::TextureSet *)jarg1;
25334   {
25335     try {
25336       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
25337     } catch (std::out_of_range& e) {
25338       {
25339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25340       };
25341     } catch (std::exception& e) {
25342       {
25343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25344       };
25345     } catch (Dali::DaliException e) {
25346       {
25347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25348       };
25349     } catch (...) {
25350       {
25351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25352       };
25353     }
25354   }
25355
25356   jresult = (unsigned long)result;
25357   return jresult;
25358 }
25359
25360
25361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
25362   void * jresult ;
25363   Dali::Property::Map *arg1 = 0 ;
25364   Dali::PropertyBuffer result;
25365
25366   arg1 = (Dali::Property::Map *)jarg1;
25367   if (!arg1) {
25368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
25369     return 0;
25370   }
25371   {
25372     try {
25373       result = Dali::PropertyBuffer::New(*arg1);
25374     } catch (std::out_of_range& e) {
25375       {
25376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25377       };
25378     } catch (std::exception& e) {
25379       {
25380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25381       };
25382     } catch (Dali::DaliException e) {
25383       {
25384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25385       };
25386     } catch (...) {
25387       {
25388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25389       };
25390     }
25391   }
25392
25393   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25394   return jresult;
25395 }
25396
25397
25398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
25399   void * jresult ;
25400   Dali::PropertyBuffer *result = 0 ;
25401
25402   {
25403     try {
25404       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
25405     } catch (std::out_of_range& e) {
25406       {
25407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25408       };
25409     } catch (std::exception& e) {
25410       {
25411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25412       };
25413     } catch (Dali::DaliException e) {
25414       {
25415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25416       };
25417     } catch (...) {
25418       {
25419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25420       };
25421     }
25422   }
25423
25424   jresult = (void *)result;
25425   return jresult;
25426 }
25427
25428
25429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
25430   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25431
25432   arg1 = (Dali::PropertyBuffer *)jarg1;
25433   {
25434     try {
25435       delete arg1;
25436     } catch (std::out_of_range& e) {
25437       {
25438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25439       };
25440     } catch (std::exception& e) {
25441       {
25442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25443       };
25444     } catch (Dali::DaliException e) {
25445       {
25446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25447       };
25448     } catch (...) {
25449       {
25450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25451       };
25452     }
25453   }
25454
25455 }
25456
25457
25458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
25459   void * jresult ;
25460   Dali::PropertyBuffer *arg1 = 0 ;
25461   Dali::PropertyBuffer *result = 0 ;
25462
25463   arg1 = (Dali::PropertyBuffer *)jarg1;
25464   if (!arg1) {
25465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25466     return 0;
25467   }
25468   {
25469     try {
25470       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
25471     } catch (std::out_of_range& e) {
25472       {
25473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25474       };
25475     } catch (std::exception& e) {
25476       {
25477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25478       };
25479     } catch (Dali::DaliException e) {
25480       {
25481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25482       };
25483     } catch (...) {
25484       {
25485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25486       };
25487     }
25488   }
25489
25490   jresult = (void *)result;
25491   return jresult;
25492 }
25493
25494
25495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
25496   void * jresult ;
25497   Dali::BaseHandle arg1 ;
25498   Dali::BaseHandle *argp1 ;
25499   Dali::PropertyBuffer result;
25500
25501   argp1 = (Dali::BaseHandle *)jarg1;
25502   if (!argp1) {
25503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25504     return 0;
25505   }
25506   arg1 = *argp1;
25507   {
25508     try {
25509       result = Dali::PropertyBuffer::DownCast(arg1);
25510     } catch (std::out_of_range& e) {
25511       {
25512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25513       };
25514     } catch (std::exception& e) {
25515       {
25516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25517       };
25518     } catch (Dali::DaliException e) {
25519       {
25520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25521       };
25522     } catch (...) {
25523       {
25524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25525       };
25526     }
25527   }
25528
25529   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25530   return jresult;
25531 }
25532
25533
25534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
25535   void * jresult ;
25536   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25537   Dali::PropertyBuffer *arg2 = 0 ;
25538   Dali::PropertyBuffer *result = 0 ;
25539
25540   arg1 = (Dali::PropertyBuffer *)jarg1;
25541   arg2 = (Dali::PropertyBuffer *)jarg2;
25542   if (!arg2) {
25543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25544     return 0;
25545   }
25546   {
25547     try {
25548       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
25549     } catch (std::out_of_range& e) {
25550       {
25551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25552       };
25553     } catch (std::exception& e) {
25554       {
25555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25556       };
25557     } catch (Dali::DaliException e) {
25558       {
25559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25560       };
25561     } catch (...) {
25562       {
25563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25564       };
25565     }
25566   }
25567
25568   jresult = (void *)result;
25569   return jresult;
25570 }
25571
25572
25573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
25574   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25575   void *arg2 = (void *) 0 ;
25576   std::size_t arg3 ;
25577
25578   arg1 = (Dali::PropertyBuffer *)jarg1;
25579   arg2 = jarg2;
25580   arg3 = (std::size_t)jarg3;
25581   {
25582     try {
25583       (arg1)->SetData((void const *)arg2,arg3);
25584     } catch (std::out_of_range& e) {
25585       {
25586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25587       };
25588     } catch (std::exception& e) {
25589       {
25590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25591       };
25592     } catch (Dali::DaliException e) {
25593       {
25594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25595       };
25596     } catch (...) {
25597       {
25598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25599       };
25600     }
25601   }
25602
25603 }
25604
25605
25606 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
25607   unsigned long jresult ;
25608   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25609   std::size_t result;
25610
25611   arg1 = (Dali::PropertyBuffer *)jarg1;
25612   {
25613     try {
25614       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
25615     } catch (std::out_of_range& e) {
25616       {
25617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25618       };
25619     } catch (std::exception& e) {
25620       {
25621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25622       };
25623     } catch (Dali::DaliException e) {
25624       {
25625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25626       };
25627     } catch (...) {
25628       {
25629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25630       };
25631     }
25632   }
25633
25634   jresult = (unsigned long)result;
25635   return jresult;
25636 }
25637
25638
25639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
25640   void * jresult ;
25641   Dali::Geometry result;
25642
25643   {
25644     try {
25645       result = Dali::Geometry::New();
25646     } catch (std::out_of_range& e) {
25647       {
25648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25649       };
25650     } catch (std::exception& e) {
25651       {
25652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25653       };
25654     } catch (Dali::DaliException e) {
25655       {
25656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25657       };
25658     } catch (...) {
25659       {
25660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25661       };
25662     }
25663   }
25664
25665   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25666   return jresult;
25667 }
25668
25669
25670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
25671   void * jresult ;
25672   Dali::Geometry *result = 0 ;
25673
25674   {
25675     try {
25676       result = (Dali::Geometry *)new Dali::Geometry();
25677     } catch (std::out_of_range& e) {
25678       {
25679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25680       };
25681     } catch (std::exception& e) {
25682       {
25683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25684       };
25685     } catch (Dali::DaliException e) {
25686       {
25687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25688       };
25689     } catch (...) {
25690       {
25691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25692       };
25693     }
25694   }
25695
25696   jresult = (void *)result;
25697   return jresult;
25698 }
25699
25700
25701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
25702   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25703
25704   arg1 = (Dali::Geometry *)jarg1;
25705   {
25706     try {
25707       delete arg1;
25708     } catch (std::out_of_range& e) {
25709       {
25710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25711       };
25712     } catch (std::exception& e) {
25713       {
25714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25715       };
25716     } catch (Dali::DaliException e) {
25717       {
25718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25719       };
25720     } catch (...) {
25721       {
25722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25723       };
25724     }
25725   }
25726
25727 }
25728
25729
25730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
25731   void * jresult ;
25732   Dali::Geometry *arg1 = 0 ;
25733   Dali::Geometry *result = 0 ;
25734
25735   arg1 = (Dali::Geometry *)jarg1;
25736   if (!arg1) {
25737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25738     return 0;
25739   }
25740   {
25741     try {
25742       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
25743     } catch (std::out_of_range& e) {
25744       {
25745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25746       };
25747     } catch (std::exception& e) {
25748       {
25749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25750       };
25751     } catch (Dali::DaliException e) {
25752       {
25753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25754       };
25755     } catch (...) {
25756       {
25757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25758       };
25759     }
25760   }
25761
25762   jresult = (void *)result;
25763   return jresult;
25764 }
25765
25766
25767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
25768   void * jresult ;
25769   Dali::BaseHandle arg1 ;
25770   Dali::BaseHandle *argp1 ;
25771   Dali::Geometry result;
25772
25773   argp1 = (Dali::BaseHandle *)jarg1;
25774   if (!argp1) {
25775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25776     return 0;
25777   }
25778   arg1 = *argp1;
25779   {
25780     try {
25781       result = Dali::Geometry::DownCast(arg1);
25782     } catch (std::out_of_range& e) {
25783       {
25784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25785       };
25786     } catch (std::exception& e) {
25787       {
25788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25789       };
25790     } catch (Dali::DaliException e) {
25791       {
25792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25793       };
25794     } catch (...) {
25795       {
25796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25797       };
25798     }
25799   }
25800
25801   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25802   return jresult;
25803 }
25804
25805
25806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
25807   void * jresult ;
25808   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25809   Dali::Geometry *arg2 = 0 ;
25810   Dali::Geometry *result = 0 ;
25811
25812   arg1 = (Dali::Geometry *)jarg1;
25813   arg2 = (Dali::Geometry *)jarg2;
25814   if (!arg2) {
25815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25816     return 0;
25817   }
25818   {
25819     try {
25820       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
25821     } catch (std::out_of_range& e) {
25822       {
25823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25824       };
25825     } catch (std::exception& e) {
25826       {
25827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25828       };
25829     } catch (Dali::DaliException e) {
25830       {
25831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25832       };
25833     } catch (...) {
25834       {
25835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25836       };
25837     }
25838   }
25839
25840   jresult = (void *)result;
25841   return jresult;
25842 }
25843
25844
25845 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
25846   unsigned long jresult ;
25847   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25848   Dali::PropertyBuffer *arg2 = 0 ;
25849   std::size_t result;
25850
25851   arg1 = (Dali::Geometry *)jarg1;
25852   arg2 = (Dali::PropertyBuffer *)jarg2;
25853   if (!arg2) {
25854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
25855     return 0;
25856   }
25857   {
25858     try {
25859       result = (arg1)->AddVertexBuffer(*arg2);
25860     } catch (std::out_of_range& e) {
25861       {
25862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25863       };
25864     } catch (std::exception& e) {
25865       {
25866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25867       };
25868     } catch (Dali::DaliException e) {
25869       {
25870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25871       };
25872     } catch (...) {
25873       {
25874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25875       };
25876     }
25877   }
25878
25879   jresult = (unsigned long)result;
25880   return jresult;
25881 }
25882
25883
25884 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
25885   unsigned long jresult ;
25886   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25887   std::size_t result;
25888
25889   arg1 = (Dali::Geometry *)jarg1;
25890   {
25891     try {
25892       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
25893     } catch (std::out_of_range& e) {
25894       {
25895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25896       };
25897     } catch (std::exception& e) {
25898       {
25899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25900       };
25901     } catch (Dali::DaliException e) {
25902       {
25903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25904       };
25905     } catch (...) {
25906       {
25907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25908       };
25909     }
25910   }
25911
25912   jresult = (unsigned long)result;
25913   return jresult;
25914 }
25915
25916
25917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
25918   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25919   std::size_t arg2 ;
25920
25921   arg1 = (Dali::Geometry *)jarg1;
25922   arg2 = (std::size_t)jarg2;
25923   {
25924     try {
25925       (arg1)->RemoveVertexBuffer(arg2);
25926     } catch (std::out_of_range& e) {
25927       {
25928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25929       };
25930     } catch (std::exception& e) {
25931       {
25932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25933       };
25934     } catch (Dali::DaliException e) {
25935       {
25936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25937       };
25938     } catch (...) {
25939       {
25940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25941       };
25942     }
25943   }
25944
25945 }
25946
25947
25948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
25949   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25950   unsigned short *arg2 = (unsigned short *) 0 ;
25951   size_t arg3 ;
25952
25953   arg1 = (Dali::Geometry *)jarg1;
25954   arg2 = jarg2;
25955   arg3 = (size_t)jarg3;
25956   {
25957     try {
25958       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
25959     } catch (std::out_of_range& e) {
25960       {
25961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25962       };
25963     } catch (std::exception& e) {
25964       {
25965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25966       };
25967     } catch (Dali::DaliException e) {
25968       {
25969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25970       };
25971     } catch (...) {
25972       {
25973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25974       };
25975     }
25976   }
25977
25978
25979
25980 }
25981
25982
25983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
25984   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25985   Dali::Geometry::Type arg2 ;
25986
25987   arg1 = (Dali::Geometry *)jarg1;
25988   arg2 = (Dali::Geometry::Type)jarg2;
25989   {
25990     try {
25991       (arg1)->SetType(arg2);
25992     } catch (std::out_of_range& e) {
25993       {
25994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25995       };
25996     } catch (std::exception& e) {
25997       {
25998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25999       };
26000     } catch (Dali::DaliException e) {
26001       {
26002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26003       };
26004     } catch (...) {
26005       {
26006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26007       };
26008     }
26009   }
26010
26011 }
26012
26013
26014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
26015   int jresult ;
26016   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26017   Dali::Geometry::Type result;
26018
26019   arg1 = (Dali::Geometry *)jarg1;
26020   {
26021     try {
26022       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
26023     } catch (std::out_of_range& e) {
26024       {
26025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26026       };
26027     } catch (std::exception& e) {
26028       {
26029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26030       };
26031     } catch (Dali::DaliException e) {
26032       {
26033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26034       };
26035     } catch (...) {
26036       {
26037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26038       };
26039     }
26040   }
26041
26042   jresult = (int)result;
26043   return jresult;
26044 }
26045
26046
26047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
26048   void * jresult ;
26049   Dali::Shader::Hint *result = 0 ;
26050
26051   {
26052     try {
26053       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
26054     } catch (std::out_of_range& e) {
26055       {
26056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26057       };
26058     } catch (std::exception& e) {
26059       {
26060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26061       };
26062     } catch (Dali::DaliException e) {
26063       {
26064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26065       };
26066     } catch (...) {
26067       {
26068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26069       };
26070     }
26071   }
26072
26073   jresult = (void *)result;
26074   return jresult;
26075 }
26076
26077
26078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
26079   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
26080
26081   arg1 = (Dali::Shader::Hint *)jarg1;
26082   {
26083     try {
26084       delete arg1;
26085     } catch (std::out_of_range& e) {
26086       {
26087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26088       };
26089     } catch (std::exception& e) {
26090       {
26091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26092       };
26093     } catch (Dali::DaliException e) {
26094       {
26095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26096       };
26097     } catch (...) {
26098       {
26099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26100       };
26101     }
26102   }
26103
26104 }
26105
26106
26107 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
26108   int jresult ;
26109   int result;
26110
26111   result = (int)Dali::Shader::Property::PROGRAM;
26112   jresult = (int)result;
26113   return jresult;
26114 }
26115
26116
26117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
26118   void * jresult ;
26119   Dali::Shader::Property *result = 0 ;
26120
26121   {
26122     try {
26123       result = (Dali::Shader::Property *)new Dali::Shader::Property();
26124     } catch (std::out_of_range& e) {
26125       {
26126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26127       };
26128     } catch (std::exception& e) {
26129       {
26130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26131       };
26132     } catch (Dali::DaliException e) {
26133       {
26134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26135       };
26136     } catch (...) {
26137       {
26138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26139       };
26140     }
26141   }
26142
26143   jresult = (void *)result;
26144   return jresult;
26145 }
26146
26147
26148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
26149   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
26150
26151   arg1 = (Dali::Shader::Property *)jarg1;
26152   {
26153     try {
26154       delete arg1;
26155     } catch (std::out_of_range& e) {
26156       {
26157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26158       };
26159     } catch (std::exception& e) {
26160       {
26161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26162       };
26163     } catch (Dali::DaliException e) {
26164       {
26165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26166       };
26167     } catch (...) {
26168       {
26169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26170       };
26171     }
26172   }
26173
26174 }
26175
26176
26177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
26178   void * jresult ;
26179   std::string *arg1 = 0 ;
26180   std::string *arg2 = 0 ;
26181   Dali::Shader::Hint::Value arg3 ;
26182   Dali::Shader result;
26183
26184   if (!jarg1) {
26185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26186     return 0;
26187   }
26188   std::string arg1_str(jarg1);
26189   arg1 = &arg1_str;
26190   if (!jarg2) {
26191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26192     return 0;
26193   }
26194   std::string arg2_str(jarg2);
26195   arg2 = &arg2_str;
26196   arg3 = (Dali::Shader::Hint::Value)jarg3;
26197   {
26198     try {
26199       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
26200     } catch (std::out_of_range& e) {
26201       {
26202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26203       };
26204     } catch (std::exception& e) {
26205       {
26206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26207       };
26208     } catch (Dali::DaliException e) {
26209       {
26210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26211       };
26212     } catch (...) {
26213       {
26214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26215       };
26216     }
26217   }
26218
26219   jresult = new Dali::Shader((const Dali::Shader &)result);
26220
26221   //argout typemap for const std::string&
26222
26223
26224   //argout typemap for const std::string&
26225
26226   return jresult;
26227 }
26228
26229
26230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
26231   void * jresult ;
26232   std::string *arg1 = 0 ;
26233   std::string *arg2 = 0 ;
26234   Dali::Shader result;
26235
26236   if (!jarg1) {
26237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26238     return 0;
26239   }
26240   std::string arg1_str(jarg1);
26241   arg1 = &arg1_str;
26242   if (!jarg2) {
26243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26244     return 0;
26245   }
26246   std::string arg2_str(jarg2);
26247   arg2 = &arg2_str;
26248   {
26249     try {
26250       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
26251     } catch (std::out_of_range& e) {
26252       {
26253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26254       };
26255     } catch (std::exception& e) {
26256       {
26257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26258       };
26259     } catch (Dali::DaliException e) {
26260       {
26261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26262       };
26263     } catch (...) {
26264       {
26265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26266       };
26267     }
26268   }
26269
26270   jresult = new Dali::Shader((const Dali::Shader &)result);
26271
26272   //argout typemap for const std::string&
26273
26274
26275   //argout typemap for const std::string&
26276
26277   return jresult;
26278 }
26279
26280
26281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
26282   void * jresult ;
26283   Dali::Shader *result = 0 ;
26284
26285   {
26286     try {
26287       result = (Dali::Shader *)new Dali::Shader();
26288     } catch (std::out_of_range& e) {
26289       {
26290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26291       };
26292     } catch (std::exception& e) {
26293       {
26294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26295       };
26296     } catch (Dali::DaliException e) {
26297       {
26298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26299       };
26300     } catch (...) {
26301       {
26302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26303       };
26304     }
26305   }
26306
26307   jresult = (void *)result;
26308   return jresult;
26309 }
26310
26311
26312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
26313   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26314
26315   arg1 = (Dali::Shader *)jarg1;
26316   {
26317     try {
26318       delete arg1;
26319     } catch (std::out_of_range& e) {
26320       {
26321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26322       };
26323     } catch (std::exception& e) {
26324       {
26325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26326       };
26327     } catch (Dali::DaliException e) {
26328       {
26329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26330       };
26331     } catch (...) {
26332       {
26333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26334       };
26335     }
26336   }
26337
26338 }
26339
26340
26341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
26342   void * jresult ;
26343   Dali::Shader *arg1 = 0 ;
26344   Dali::Shader *result = 0 ;
26345
26346   arg1 = (Dali::Shader *)jarg1;
26347   if (!arg1) {
26348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26349     return 0;
26350   }
26351   {
26352     try {
26353       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
26354     } catch (std::out_of_range& e) {
26355       {
26356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26357       };
26358     } catch (std::exception& e) {
26359       {
26360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26361       };
26362     } catch (Dali::DaliException e) {
26363       {
26364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26365       };
26366     } catch (...) {
26367       {
26368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26369       };
26370     }
26371   }
26372
26373   jresult = (void *)result;
26374   return jresult;
26375 }
26376
26377
26378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
26379   void * jresult ;
26380   Dali::BaseHandle arg1 ;
26381   Dali::BaseHandle *argp1 ;
26382   Dali::Shader result;
26383
26384   argp1 = (Dali::BaseHandle *)jarg1;
26385   if (!argp1) {
26386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26387     return 0;
26388   }
26389   arg1 = *argp1;
26390   {
26391     try {
26392       result = Dali::Shader::DownCast(arg1);
26393     } catch (std::out_of_range& e) {
26394       {
26395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26396       };
26397     } catch (std::exception& e) {
26398       {
26399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26400       };
26401     } catch (Dali::DaliException e) {
26402       {
26403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26404       };
26405     } catch (...) {
26406       {
26407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26408       };
26409     }
26410   }
26411
26412   jresult = new Dali::Shader((const Dali::Shader &)result);
26413   return jresult;
26414 }
26415
26416
26417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
26418   void * jresult ;
26419   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26420   Dali::Shader *arg2 = 0 ;
26421   Dali::Shader *result = 0 ;
26422
26423   arg1 = (Dali::Shader *)jarg1;
26424   arg2 = (Dali::Shader *)jarg2;
26425   if (!arg2) {
26426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26427     return 0;
26428   }
26429   {
26430     try {
26431       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
26432     } catch (std::out_of_range& e) {
26433       {
26434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26435       };
26436     } catch (std::exception& e) {
26437       {
26438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26439       };
26440     } catch (Dali::DaliException e) {
26441       {
26442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26443       };
26444     } catch (...) {
26445       {
26446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26447       };
26448     }
26449   }
26450
26451   jresult = (void *)result;
26452   return jresult;
26453 }
26454
26455
26456 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
26457   int jresult ;
26458   int result;
26459
26460   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
26461   jresult = (int)result;
26462   return jresult;
26463 }
26464
26465
26466 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
26467   int jresult ;
26468   int result;
26469
26470   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
26471   jresult = (int)result;
26472   return jresult;
26473 }
26474
26475
26476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
26477   int jresult ;
26478   int result;
26479
26480   result = (int)Dali::Renderer::Property::BLEND_MODE;
26481   jresult = (int)result;
26482   return jresult;
26483 }
26484
26485
26486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
26487   int jresult ;
26488   int result;
26489
26490   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
26491   jresult = (int)result;
26492   return jresult;
26493 }
26494
26495
26496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
26497   int jresult ;
26498   int result;
26499
26500   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
26501   jresult = (int)result;
26502   return jresult;
26503 }
26504
26505
26506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
26507   int jresult ;
26508   int result;
26509
26510   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
26511   jresult = (int)result;
26512   return jresult;
26513 }
26514
26515
26516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
26517   int jresult ;
26518   int result;
26519
26520   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
26521   jresult = (int)result;
26522   return jresult;
26523 }
26524
26525
26526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
26527   int jresult ;
26528   int result;
26529
26530   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
26531   jresult = (int)result;
26532   return jresult;
26533 }
26534
26535
26536 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
26537   int jresult ;
26538   int result;
26539
26540   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
26541   jresult = (int)result;
26542   return jresult;
26543 }
26544
26545
26546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
26547   int jresult ;
26548   int result;
26549
26550   result = (int)Dali::Renderer::Property::BLEND_COLOR;
26551   jresult = (int)result;
26552   return jresult;
26553 }
26554
26555
26556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
26557   int jresult ;
26558   int result;
26559
26560   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
26561   jresult = (int)result;
26562   return jresult;
26563 }
26564
26565
26566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
26567   int jresult ;
26568   int result;
26569
26570   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
26571   jresult = (int)result;
26572   return jresult;
26573 }
26574
26575
26576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
26577   int jresult ;
26578   int result;
26579
26580   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
26581   jresult = (int)result;
26582   return jresult;
26583 }
26584
26585
26586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
26587   int jresult ;
26588   int result;
26589
26590   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
26591   jresult = (int)result;
26592   return jresult;
26593 }
26594
26595
26596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
26597   int jresult ;
26598   int result;
26599
26600   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
26601   jresult = (int)result;
26602   return jresult;
26603 }
26604
26605
26606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
26607   int jresult ;
26608   int result;
26609
26610   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
26611   jresult = (int)result;
26612   return jresult;
26613 }
26614
26615
26616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
26617   int jresult ;
26618   int result;
26619
26620   result = (int)Dali::Renderer::Property::RENDER_MODE;
26621   jresult = (int)result;
26622   return jresult;
26623 }
26624
26625
26626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
26627   int jresult ;
26628   int result;
26629
26630   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
26631   jresult = (int)result;
26632   return jresult;
26633 }
26634
26635
26636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
26637   int jresult ;
26638   int result;
26639
26640   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
26641   jresult = (int)result;
26642   return jresult;
26643 }
26644
26645
26646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
26647   int jresult ;
26648   int result;
26649
26650   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
26651   jresult = (int)result;
26652   return jresult;
26653 }
26654
26655
26656 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
26657   int jresult ;
26658   int result;
26659
26660   result = (int)Dali::Renderer::Property::STENCIL_MASK;
26661   jresult = (int)result;
26662   return jresult;
26663 }
26664
26665
26666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
26667   int jresult ;
26668   int result;
26669
26670   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
26671   jresult = (int)result;
26672   return jresult;
26673 }
26674
26675
26676 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
26677   int jresult ;
26678   int result;
26679
26680   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
26681   jresult = (int)result;
26682   return jresult;
26683 }
26684
26685
26686 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
26687   int jresult ;
26688   int result;
26689
26690   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
26691   jresult = (int)result;
26692   return jresult;
26693 }
26694
26695
26696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
26697   void * jresult ;
26698   Dali::Renderer::Property *result = 0 ;
26699
26700   {
26701     try {
26702       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
26703     } catch (std::out_of_range& e) {
26704       {
26705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26706       };
26707     } catch (std::exception& e) {
26708       {
26709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26710       };
26711     } catch (Dali::DaliException e) {
26712       {
26713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26714       };
26715     } catch (...) {
26716       {
26717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26718       };
26719     }
26720   }
26721
26722   jresult = (void *)result;
26723   return jresult;
26724 }
26725
26726
26727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
26728   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
26729
26730   arg1 = (Dali::Renderer::Property *)jarg1;
26731   {
26732     try {
26733       delete arg1;
26734     } catch (std::out_of_range& e) {
26735       {
26736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26737       };
26738     } catch (std::exception& e) {
26739       {
26740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26741       };
26742     } catch (Dali::DaliException e) {
26743       {
26744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26745       };
26746     } catch (...) {
26747       {
26748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26749       };
26750     }
26751   }
26752
26753 }
26754
26755
26756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
26757   void * jresult ;
26758   Dali::Geometry *arg1 = 0 ;
26759   Dali::Shader *arg2 = 0 ;
26760   Dali::Renderer result;
26761
26762   arg1 = (Dali::Geometry *)jarg1;
26763   if (!arg1) {
26764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26765     return 0;
26766   }
26767   arg2 = (Dali::Shader *)jarg2;
26768   if (!arg2) {
26769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
26770     return 0;
26771   }
26772   {
26773     try {
26774       result = Dali::Renderer::New(*arg1,*arg2);
26775     } catch (std::out_of_range& e) {
26776       {
26777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26778       };
26779     } catch (std::exception& e) {
26780       {
26781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26782       };
26783     } catch (Dali::DaliException e) {
26784       {
26785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26786       };
26787     } catch (...) {
26788       {
26789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26790       };
26791     }
26792   }
26793
26794   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26795   return jresult;
26796 }
26797
26798
26799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
26800   void * jresult ;
26801   Dali::Renderer *result = 0 ;
26802
26803   {
26804     try {
26805       result = (Dali::Renderer *)new Dali::Renderer();
26806     } catch (std::out_of_range& e) {
26807       {
26808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26809       };
26810     } catch (std::exception& e) {
26811       {
26812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26813       };
26814     } catch (Dali::DaliException e) {
26815       {
26816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26817       };
26818     } catch (...) {
26819       {
26820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26821       };
26822     }
26823   }
26824
26825   jresult = (void *)result;
26826   return jresult;
26827 }
26828
26829
26830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
26831   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26832
26833   arg1 = (Dali::Renderer *)jarg1;
26834   {
26835     try {
26836       delete arg1;
26837     } catch (std::out_of_range& e) {
26838       {
26839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26840       };
26841     } catch (std::exception& e) {
26842       {
26843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26844       };
26845     } catch (Dali::DaliException e) {
26846       {
26847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26848       };
26849     } catch (...) {
26850       {
26851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26852       };
26853     }
26854   }
26855
26856 }
26857
26858
26859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
26860   void * jresult ;
26861   Dali::Renderer *arg1 = 0 ;
26862   Dali::Renderer *result = 0 ;
26863
26864   arg1 = (Dali::Renderer *)jarg1;
26865   if (!arg1) {
26866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26867     return 0;
26868   }
26869   {
26870     try {
26871       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
26872     } catch (std::out_of_range& e) {
26873       {
26874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26875       };
26876     } catch (std::exception& e) {
26877       {
26878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26879       };
26880     } catch (Dali::DaliException e) {
26881       {
26882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26883       };
26884     } catch (...) {
26885       {
26886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26887       };
26888     }
26889   }
26890
26891   jresult = (void *)result;
26892   return jresult;
26893 }
26894
26895
26896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
26897   void * jresult ;
26898   Dali::BaseHandle arg1 ;
26899   Dali::BaseHandle *argp1 ;
26900   Dali::Renderer result;
26901
26902   argp1 = (Dali::BaseHandle *)jarg1;
26903   if (!argp1) {
26904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26905     return 0;
26906   }
26907   arg1 = *argp1;
26908   {
26909     try {
26910       result = Dali::Renderer::DownCast(arg1);
26911     } catch (std::out_of_range& e) {
26912       {
26913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26914       };
26915     } catch (std::exception& e) {
26916       {
26917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26918       };
26919     } catch (Dali::DaliException e) {
26920       {
26921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26922       };
26923     } catch (...) {
26924       {
26925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26926       };
26927     }
26928   }
26929
26930   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26931   return jresult;
26932 }
26933
26934
26935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
26936   void * jresult ;
26937   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26938   Dali::Renderer *arg2 = 0 ;
26939   Dali::Renderer *result = 0 ;
26940
26941   arg1 = (Dali::Renderer *)jarg1;
26942   arg2 = (Dali::Renderer *)jarg2;
26943   if (!arg2) {
26944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26945     return 0;
26946   }
26947   {
26948     try {
26949       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
26950     } catch (std::out_of_range& e) {
26951       {
26952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26953       };
26954     } catch (std::exception& e) {
26955       {
26956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26957       };
26958     } catch (Dali::DaliException e) {
26959       {
26960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26961       };
26962     } catch (...) {
26963       {
26964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26965       };
26966     }
26967   }
26968
26969   jresult = (void *)result;
26970   return jresult;
26971 }
26972
26973
26974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
26975   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26976   Dali::Geometry *arg2 = 0 ;
26977
26978   arg1 = (Dali::Renderer *)jarg1;
26979   arg2 = (Dali::Geometry *)jarg2;
26980   if (!arg2) {
26981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26982     return ;
26983   }
26984   {
26985     try {
26986       (arg1)->SetGeometry(*arg2);
26987     } catch (std::out_of_range& e) {
26988       {
26989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26990       };
26991     } catch (std::exception& e) {
26992       {
26993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26994       };
26995     } catch (Dali::DaliException e) {
26996       {
26997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26998       };
26999     } catch (...) {
27000       {
27001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27002       };
27003     }
27004   }
27005
27006 }
27007
27008
27009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
27010   void * jresult ;
27011   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27012   Dali::Geometry result;
27013
27014   arg1 = (Dali::Renderer *)jarg1;
27015   {
27016     try {
27017       result = ((Dali::Renderer const *)arg1)->GetGeometry();
27018     } catch (std::out_of_range& e) {
27019       {
27020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27021       };
27022     } catch (std::exception& e) {
27023       {
27024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27025       };
27026     } catch (Dali::DaliException e) {
27027       {
27028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27029       };
27030     } catch (...) {
27031       {
27032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27033       };
27034     }
27035   }
27036
27037   jresult = new Dali::Geometry((const Dali::Geometry &)result);
27038   return jresult;
27039 }
27040
27041
27042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
27043   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27044   int arg2 ;
27045   int arg3 ;
27046
27047   arg1 = (Dali::Renderer *)jarg1;
27048   arg2 = (int)jarg2;
27049   arg3 = (int)jarg3;
27050   {
27051     try {
27052       (arg1)->SetIndexRange(arg2,arg3);
27053     } catch (std::out_of_range& e) {
27054       {
27055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27056       };
27057     } catch (std::exception& e) {
27058       {
27059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27060       };
27061     } catch (Dali::DaliException e) {
27062       {
27063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27064       };
27065     } catch (...) {
27066       {
27067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27068       };
27069     }
27070   }
27071
27072 }
27073
27074
27075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
27076   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27077   Dali::TextureSet *arg2 = 0 ;
27078
27079   arg1 = (Dali::Renderer *)jarg1;
27080   arg2 = (Dali::TextureSet *)jarg2;
27081   if (!arg2) {
27082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
27083     return ;
27084   }
27085   {
27086     try {
27087       (arg1)->SetTextures(*arg2);
27088     } catch (std::out_of_range& e) {
27089       {
27090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27091       };
27092     } catch (std::exception& e) {
27093       {
27094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27095       };
27096     } catch (Dali::DaliException e) {
27097       {
27098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27099       };
27100     } catch (...) {
27101       {
27102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27103       };
27104     }
27105   }
27106
27107 }
27108
27109
27110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
27111   void * jresult ;
27112   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27113   Dali::TextureSet result;
27114
27115   arg1 = (Dali::Renderer *)jarg1;
27116   {
27117     try {
27118       result = ((Dali::Renderer const *)arg1)->GetTextures();
27119     } catch (std::out_of_range& e) {
27120       {
27121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27122       };
27123     } catch (std::exception& e) {
27124       {
27125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27126       };
27127     } catch (Dali::DaliException e) {
27128       {
27129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27130       };
27131     } catch (...) {
27132       {
27133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27134       };
27135     }
27136   }
27137
27138   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
27139   return jresult;
27140 }
27141
27142
27143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
27144   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27145   Dali::Shader *arg2 = 0 ;
27146
27147   arg1 = (Dali::Renderer *)jarg1;
27148   arg2 = (Dali::Shader *)jarg2;
27149   if (!arg2) {
27150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
27151     return ;
27152   }
27153   {
27154     try {
27155       (arg1)->SetShader(*arg2);
27156     } catch (std::out_of_range& e) {
27157       {
27158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27159       };
27160     } catch (std::exception& e) {
27161       {
27162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27163       };
27164     } catch (Dali::DaliException e) {
27165       {
27166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27167       };
27168     } catch (...) {
27169       {
27170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27171       };
27172     }
27173   }
27174
27175 }
27176
27177
27178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
27179   void * jresult ;
27180   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27181   Dali::Shader result;
27182
27183   arg1 = (Dali::Renderer *)jarg1;
27184   {
27185     try {
27186       result = ((Dali::Renderer const *)arg1)->GetShader();
27187     } catch (std::out_of_range& e) {
27188       {
27189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27190       };
27191     } catch (std::exception& e) {
27192       {
27193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27194       };
27195     } catch (Dali::DaliException e) {
27196       {
27197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27198       };
27199     } catch (...) {
27200       {
27201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27202       };
27203     }
27204   }
27205
27206   jresult = new Dali::Shader((const Dali::Shader &)result);
27207   return jresult;
27208 }
27209
27210
27211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
27212   void * jresult ;
27213   Dali::FrameBuffer::Attachment *result = 0 ;
27214
27215   {
27216     try {
27217       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
27218     } catch (std::out_of_range& e) {
27219       {
27220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27221       };
27222     } catch (std::exception& e) {
27223       {
27224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27225       };
27226     } catch (Dali::DaliException e) {
27227       {
27228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27229       };
27230     } catch (...) {
27231       {
27232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27233       };
27234     }
27235   }
27236
27237   jresult = (void *)result;
27238   return jresult;
27239 }
27240
27241
27242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
27243   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
27244
27245   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
27246   {
27247     try {
27248       delete arg1;
27249     } catch (std::out_of_range& e) {
27250       {
27251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27252       };
27253     } catch (std::exception& e) {
27254       {
27255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27256       };
27257     } catch (Dali::DaliException e) {
27258       {
27259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27260       };
27261     } catch (...) {
27262       {
27263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27264       };
27265     }
27266   }
27267
27268 }
27269
27270
27271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
27272   void * jresult ;
27273   unsigned int arg1 ;
27274   unsigned int arg2 ;
27275   unsigned int arg3 ;
27276   Dali::FrameBuffer result;
27277
27278   arg1 = (unsigned int)jarg1;
27279   arg2 = (unsigned int)jarg2;
27280   arg3 = (unsigned int)jarg3;
27281   {
27282     try {
27283       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
27284     } catch (std::out_of_range& e) {
27285       {
27286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27287       };
27288     } catch (std::exception& e) {
27289       {
27290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27291       };
27292     } catch (Dali::DaliException e) {
27293       {
27294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27295       };
27296     } catch (...) {
27297       {
27298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27299       };
27300     }
27301   }
27302
27303   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27304   return jresult;
27305 }
27306
27307
27308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
27309   void * jresult ;
27310   Dali::FrameBuffer *result = 0 ;
27311
27312   {
27313     try {
27314       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
27315     } catch (std::out_of_range& e) {
27316       {
27317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27318       };
27319     } catch (std::exception& e) {
27320       {
27321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27322       };
27323     } catch (Dali::DaliException e) {
27324       {
27325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27326       };
27327     } catch (...) {
27328       {
27329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27330       };
27331     }
27332   }
27333
27334   jresult = (void *)result;
27335   return jresult;
27336 }
27337
27338
27339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
27340   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27341
27342   arg1 = (Dali::FrameBuffer *)jarg1;
27343   {
27344     try {
27345       delete arg1;
27346     } catch (std::out_of_range& e) {
27347       {
27348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27349       };
27350     } catch (std::exception& e) {
27351       {
27352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27353       };
27354     } catch (Dali::DaliException e) {
27355       {
27356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27357       };
27358     } catch (...) {
27359       {
27360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27361       };
27362     }
27363   }
27364
27365 }
27366
27367
27368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
27369   void * jresult ;
27370   Dali::FrameBuffer *arg1 = 0 ;
27371   Dali::FrameBuffer *result = 0 ;
27372
27373   arg1 = (Dali::FrameBuffer *)jarg1;
27374   if (!arg1) {
27375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27376     return 0;
27377   }
27378   {
27379     try {
27380       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
27381     } catch (std::out_of_range& e) {
27382       {
27383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27384       };
27385     } catch (std::exception& e) {
27386       {
27387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27388       };
27389     } catch (Dali::DaliException e) {
27390       {
27391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27392       };
27393     } catch (...) {
27394       {
27395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27396       };
27397     }
27398   }
27399
27400   jresult = (void *)result;
27401   return jresult;
27402 }
27403
27404
27405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
27406   void * jresult ;
27407   Dali::BaseHandle arg1 ;
27408   Dali::BaseHandle *argp1 ;
27409   Dali::FrameBuffer result;
27410
27411   argp1 = (Dali::BaseHandle *)jarg1;
27412   if (!argp1) {
27413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27414     return 0;
27415   }
27416   arg1 = *argp1;
27417   {
27418     try {
27419       result = Dali::FrameBuffer::DownCast(arg1);
27420     } catch (std::out_of_range& e) {
27421       {
27422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27423       };
27424     } catch (std::exception& e) {
27425       {
27426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27427       };
27428     } catch (Dali::DaliException e) {
27429       {
27430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27431       };
27432     } catch (...) {
27433       {
27434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27435       };
27436     }
27437   }
27438
27439   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27440   return jresult;
27441 }
27442
27443
27444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
27445   void * jresult ;
27446   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27447   Dali::FrameBuffer *arg2 = 0 ;
27448   Dali::FrameBuffer *result = 0 ;
27449
27450   arg1 = (Dali::FrameBuffer *)jarg1;
27451   arg2 = (Dali::FrameBuffer *)jarg2;
27452   if (!arg2) {
27453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27454     return 0;
27455   }
27456   {
27457     try {
27458       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
27459     } catch (std::out_of_range& e) {
27460       {
27461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27462       };
27463     } catch (std::exception& e) {
27464       {
27465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27466       };
27467     } catch (Dali::DaliException e) {
27468       {
27469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27470       };
27471     } catch (...) {
27472       {
27473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27474       };
27475     }
27476   }
27477
27478   jresult = (void *)result;
27479   return jresult;
27480 }
27481
27482
27483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
27484   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27485   Dali::Texture *arg2 = 0 ;
27486
27487   arg1 = (Dali::FrameBuffer *)jarg1;
27488   arg2 = (Dali::Texture *)jarg2;
27489   if (!arg2) {
27490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27491     return ;
27492   }
27493   {
27494     try {
27495       (arg1)->AttachColorTexture(*arg2);
27496     } catch (std::out_of_range& e) {
27497       {
27498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27499       };
27500     } catch (std::exception& e) {
27501       {
27502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27503       };
27504     } catch (Dali::DaliException e) {
27505       {
27506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27507       };
27508     } catch (...) {
27509       {
27510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27511       };
27512     }
27513   }
27514
27515 }
27516
27517
27518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
27519   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27520   Dali::Texture *arg2 = 0 ;
27521   unsigned int arg3 ;
27522   unsigned int arg4 ;
27523
27524   arg1 = (Dali::FrameBuffer *)jarg1;
27525   arg2 = (Dali::Texture *)jarg2;
27526   if (!arg2) {
27527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27528     return ;
27529   }
27530   arg3 = (unsigned int)jarg3;
27531   arg4 = (unsigned int)jarg4;
27532   {
27533     try {
27534       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
27535     } catch (std::out_of_range& e) {
27536       {
27537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27538       };
27539     } catch (std::exception& e) {
27540       {
27541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27542       };
27543     } catch (Dali::DaliException e) {
27544       {
27545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27546       };
27547     } catch (...) {
27548       {
27549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27550       };
27551     }
27552   }
27553
27554 }
27555
27556
27557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
27558   void * jresult ;
27559   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27560   Dali::Texture result;
27561
27562   arg1 = (Dali::FrameBuffer *)jarg1;
27563   {
27564     try {
27565       result = (arg1)->GetColorTexture();
27566     } catch (std::out_of_range& e) {
27567       {
27568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27569       };
27570     } catch (std::exception& e) {
27571       {
27572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27573       };
27574     } catch (Dali::DaliException e) {
27575       {
27576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27577       };
27578     } catch (...) {
27579       {
27580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27581       };
27582     }
27583   }
27584
27585   jresult = new Dali::Texture((const Dali::Texture &)result);
27586   return jresult;
27587 }
27588
27589
27590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
27591   void * jresult ;
27592   Dali::RenderTaskList *result = 0 ;
27593
27594   {
27595     try {
27596       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
27597     } catch (std::out_of_range& e) {
27598       {
27599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27600       };
27601     } catch (std::exception& e) {
27602       {
27603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27604       };
27605     } catch (Dali::DaliException e) {
27606       {
27607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27608       };
27609     } catch (...) {
27610       {
27611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27612       };
27613     }
27614   }
27615
27616   jresult = (void *)result;
27617   return jresult;
27618 }
27619
27620
27621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
27622   void * jresult ;
27623   Dali::BaseHandle arg1 ;
27624   Dali::BaseHandle *argp1 ;
27625   Dali::RenderTaskList result;
27626
27627   argp1 = (Dali::BaseHandle *)jarg1;
27628   if (!argp1) {
27629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27630     return 0;
27631   }
27632   arg1 = *argp1;
27633   {
27634     try {
27635       result = Dali::RenderTaskList::DownCast(arg1);
27636     } catch (std::out_of_range& e) {
27637       {
27638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27639       };
27640     } catch (std::exception& e) {
27641       {
27642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27643       };
27644     } catch (Dali::DaliException e) {
27645       {
27646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27647       };
27648     } catch (...) {
27649       {
27650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27651       };
27652     }
27653   }
27654
27655   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
27656   return jresult;
27657 }
27658
27659
27660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
27661   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27662
27663   arg1 = (Dali::RenderTaskList *)jarg1;
27664   {
27665     try {
27666       delete arg1;
27667     } catch (std::out_of_range& e) {
27668       {
27669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27670       };
27671     } catch (std::exception& e) {
27672       {
27673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27674       };
27675     } catch (Dali::DaliException e) {
27676       {
27677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27678       };
27679     } catch (...) {
27680       {
27681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27682       };
27683     }
27684   }
27685
27686 }
27687
27688
27689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
27690   void * jresult ;
27691   Dali::RenderTaskList *arg1 = 0 ;
27692   Dali::RenderTaskList *result = 0 ;
27693
27694   arg1 = (Dali::RenderTaskList *)jarg1;
27695   if (!arg1) {
27696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27697     return 0;
27698   }
27699   {
27700     try {
27701       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
27702     } catch (std::out_of_range& e) {
27703       {
27704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27705       };
27706     } catch (std::exception& e) {
27707       {
27708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27709       };
27710     } catch (Dali::DaliException e) {
27711       {
27712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27713       };
27714     } catch (...) {
27715       {
27716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27717       };
27718     }
27719   }
27720
27721   jresult = (void *)result;
27722   return jresult;
27723 }
27724
27725
27726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
27727   void * jresult ;
27728   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27729   Dali::RenderTaskList *arg2 = 0 ;
27730   Dali::RenderTaskList *result = 0 ;
27731
27732   arg1 = (Dali::RenderTaskList *)jarg1;
27733   arg2 = (Dali::RenderTaskList *)jarg2;
27734   if (!arg2) {
27735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27736     return 0;
27737   }
27738   {
27739     try {
27740       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
27741     } catch (std::out_of_range& e) {
27742       {
27743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27744       };
27745     } catch (std::exception& e) {
27746       {
27747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27748       };
27749     } catch (Dali::DaliException e) {
27750       {
27751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27752       };
27753     } catch (...) {
27754       {
27755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27756       };
27757     }
27758   }
27759
27760   jresult = (void *)result;
27761   return jresult;
27762 }
27763
27764
27765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
27766   void * jresult ;
27767   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27768   Dali::RenderTask result;
27769
27770   arg1 = (Dali::RenderTaskList *)jarg1;
27771   {
27772     try {
27773       result = (arg1)->CreateTask();
27774     } catch (std::out_of_range& e) {
27775       {
27776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27777       };
27778     } catch (std::exception& e) {
27779       {
27780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27781       };
27782     } catch (Dali::DaliException e) {
27783       {
27784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27785       };
27786     } catch (...) {
27787       {
27788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27789       };
27790     }
27791   }
27792
27793   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27794   return jresult;
27795 }
27796
27797
27798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
27799   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27800   Dali::RenderTask arg2 ;
27801   Dali::RenderTask *argp2 ;
27802
27803   arg1 = (Dali::RenderTaskList *)jarg1;
27804   argp2 = (Dali::RenderTask *)jarg2;
27805   if (!argp2) {
27806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
27807     return ;
27808   }
27809   arg2 = *argp2;
27810   {
27811     try {
27812       (arg1)->RemoveTask(arg2);
27813     } catch (std::out_of_range& e) {
27814       {
27815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27816       };
27817     } catch (std::exception& e) {
27818       {
27819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27820       };
27821     } catch (Dali::DaliException e) {
27822       {
27823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27824       };
27825     } catch (...) {
27826       {
27827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27828       };
27829     }
27830   }
27831
27832 }
27833
27834
27835 //// ===============================================end part 1 =================
27836
27837 //// ========================= part 2 ===============================
27838
27839 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
27840   unsigned int jresult ;
27841   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27842   unsigned int result;
27843
27844   arg1 = (Dali::RenderTaskList *)jarg1;
27845   {
27846     try {
27847       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
27848     } catch (std::out_of_range& e) {
27849       {
27850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27851       };
27852     } catch (std::exception& e) {
27853       {
27854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27855       };
27856     } catch (Dali::DaliException e) {
27857       {
27858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27859       };
27860     } catch (...) {
27861       {
27862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27863       };
27864     }
27865   }
27866
27867   jresult = result;
27868   return jresult;
27869 }
27870
27871
27872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
27873   void * jresult ;
27874   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27875   unsigned int arg2 ;
27876   Dali::RenderTask result;
27877
27878   arg1 = (Dali::RenderTaskList *)jarg1;
27879   arg2 = (unsigned int)jarg2;
27880   {
27881     try {
27882       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
27883     } catch (std::out_of_range& e) {
27884       {
27885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27886       };
27887     } catch (std::exception& e) {
27888       {
27889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27890       };
27891     } catch (Dali::DaliException e) {
27892       {
27893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27894       };
27895     } catch (...) {
27896       {
27897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27898       };
27899     }
27900   }
27901
27902   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27903   return jresult;
27904 }
27905
27906
27907 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
27908   int jresult ;
27909   int result;
27910
27911   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
27912   jresult = (int)result;
27913   return jresult;
27914 }
27915
27916
27917 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
27918   int jresult ;
27919   int result;
27920
27921   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
27922   jresult = (int)result;
27923   return jresult;
27924 }
27925
27926
27927 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
27928   int jresult ;
27929   int result;
27930
27931   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
27932   jresult = (int)result;
27933   return jresult;
27934 }
27935
27936
27937 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
27938   int jresult ;
27939   int result;
27940
27941   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
27942   jresult = (int)result;
27943   return jresult;
27944 }
27945
27946
27947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
27948   void * jresult ;
27949   Dali::RenderTask::Property *result = 0 ;
27950
27951   {
27952     try {
27953       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
27954     } catch (std::out_of_range& e) {
27955       {
27956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27957       };
27958     } catch (std::exception& e) {
27959       {
27960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27961       };
27962     } catch (Dali::DaliException e) {
27963       {
27964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27965       };
27966     } catch (...) {
27967       {
27968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27969       };
27970     }
27971   }
27972
27973   jresult = (void *)result;
27974   return jresult;
27975 }
27976
27977
27978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
27979   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
27980
27981   arg1 = (Dali::RenderTask::Property *)jarg1;
27982   {
27983     try {
27984       delete arg1;
27985     } catch (std::out_of_range& e) {
27986       {
27987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27988       };
27989     } catch (std::exception& e) {
27990       {
27991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27992       };
27993     } catch (Dali::DaliException e) {
27994       {
27995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27996       };
27997     } catch (...) {
27998       {
27999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28000       };
28001     }
28002   }
28003
28004 }
28005
28006
28007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
28008   void * jresult ;
28009   bool (*result)(Dali::Vector2 &) = 0 ;
28010
28011   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
28012   jresult = (void *)result;
28013   return jresult;
28014 }
28015
28016
28017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
28018   void * jresult ;
28019   bool (*result)(Dali::Vector2 &) = 0 ;
28020
28021   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
28022   jresult = (void *)result;
28023   return jresult;
28024 }
28025
28026
28027 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
28028   unsigned int jresult ;
28029   bool result;
28030
28031   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
28032   jresult = result;
28033   return jresult;
28034 }
28035
28036
28037 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
28038   unsigned int jresult ;
28039   bool result;
28040
28041   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
28042   jresult = result;
28043   return jresult;
28044 }
28045
28046
28047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
28048   void * jresult ;
28049   Dali::Vector4 *result = 0 ;
28050
28051   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
28052   jresult = (void *)result;
28053   return jresult;
28054 }
28055
28056
28057 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
28058   unsigned int jresult ;
28059   bool result;
28060
28061   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
28062   jresult = result;
28063   return jresult;
28064 }
28065
28066
28067 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
28068   unsigned int jresult ;
28069   bool result;
28070
28071   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
28072   jresult = result;
28073   return jresult;
28074 }
28075
28076
28077 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
28078   unsigned int jresult ;
28079   unsigned int result;
28080
28081   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
28082   jresult = result;
28083   return jresult;
28084 }
28085
28086
28087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
28088   void * jresult ;
28089   Dali::RenderTask *result = 0 ;
28090
28091   {
28092     try {
28093       result = (Dali::RenderTask *)new Dali::RenderTask();
28094     } catch (std::out_of_range& e) {
28095       {
28096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28097       };
28098     } catch (std::exception& e) {
28099       {
28100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28101       };
28102     } catch (Dali::DaliException e) {
28103       {
28104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28105       };
28106     } catch (...) {
28107       {
28108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28109       };
28110     }
28111   }
28112
28113   jresult = (void *)result;
28114   return jresult;
28115 }
28116
28117
28118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
28119   void * jresult ;
28120   Dali::BaseHandle arg1 ;
28121   Dali::BaseHandle *argp1 ;
28122   Dali::RenderTask result;
28123
28124   argp1 = (Dali::BaseHandle *)jarg1;
28125   if (!argp1) {
28126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28127     return 0;
28128   }
28129   arg1 = *argp1;
28130   {
28131     try {
28132       result = Dali::RenderTask::DownCast(arg1);
28133     } catch (std::out_of_range& e) {
28134       {
28135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28136       };
28137     } catch (std::exception& e) {
28138       {
28139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28140       };
28141     } catch (Dali::DaliException e) {
28142       {
28143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28144       };
28145     } catch (...) {
28146       {
28147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28148       };
28149     }
28150   }
28151
28152   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28153   return jresult;
28154 }
28155
28156
28157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
28158   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28159
28160   arg1 = (Dali::RenderTask *)jarg1;
28161   {
28162     try {
28163       delete arg1;
28164     } catch (std::out_of_range& e) {
28165       {
28166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28167       };
28168     } catch (std::exception& e) {
28169       {
28170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28171       };
28172     } catch (Dali::DaliException e) {
28173       {
28174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28175       };
28176     } catch (...) {
28177       {
28178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28179       };
28180     }
28181   }
28182
28183 }
28184
28185
28186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
28187   void * jresult ;
28188   Dali::RenderTask *arg1 = 0 ;
28189   Dali::RenderTask *result = 0 ;
28190
28191   arg1 = (Dali::RenderTask *)jarg1;
28192   if (!arg1) {
28193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28194     return 0;
28195   }
28196   {
28197     try {
28198       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
28199     } catch (std::out_of_range& e) {
28200       {
28201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28202       };
28203     } catch (std::exception& e) {
28204       {
28205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28206       };
28207     } catch (Dali::DaliException e) {
28208       {
28209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28210       };
28211     } catch (...) {
28212       {
28213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28214       };
28215     }
28216   }
28217
28218   jresult = (void *)result;
28219   return jresult;
28220 }
28221
28222
28223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
28224   void * jresult ;
28225   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28226   Dali::RenderTask *arg2 = 0 ;
28227   Dali::RenderTask *result = 0 ;
28228
28229   arg1 = (Dali::RenderTask *)jarg1;
28230   arg2 = (Dali::RenderTask *)jarg2;
28231   if (!arg2) {
28232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28233     return 0;
28234   }
28235   {
28236     try {
28237       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
28238     } catch (std::out_of_range& e) {
28239       {
28240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28241       };
28242     } catch (std::exception& e) {
28243       {
28244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28245       };
28246     } catch (Dali::DaliException e) {
28247       {
28248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28249       };
28250     } catch (...) {
28251       {
28252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28253       };
28254     }
28255   }
28256
28257   jresult = (void *)result;
28258   return jresult;
28259 }
28260
28261
28262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
28263   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28264   Dali::Actor arg2 ;
28265   Dali::Actor *argp2 ;
28266
28267   arg1 = (Dali::RenderTask *)jarg1;
28268   argp2 = (Dali::Actor *)jarg2;
28269   if (!argp2) {
28270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28271     return ;
28272   }
28273   arg2 = *argp2;
28274   {
28275     try {
28276       (arg1)->SetSourceActor(arg2);
28277     } catch (std::out_of_range& e) {
28278       {
28279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28280       };
28281     } catch (std::exception& e) {
28282       {
28283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28284       };
28285     } catch (Dali::DaliException e) {
28286       {
28287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28288       };
28289     } catch (...) {
28290       {
28291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28292       };
28293     }
28294   }
28295
28296 }
28297
28298
28299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
28300   void * jresult ;
28301   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28302   Dali::Actor result;
28303
28304   arg1 = (Dali::RenderTask *)jarg1;
28305   {
28306     try {
28307       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
28308     } catch (std::out_of_range& e) {
28309       {
28310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28311       };
28312     } catch (std::exception& e) {
28313       {
28314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28315       };
28316     } catch (Dali::DaliException e) {
28317       {
28318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28319       };
28320     } catch (...) {
28321       {
28322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28323       };
28324     }
28325   }
28326
28327   jresult = new Dali::Actor((const Dali::Actor &)result);
28328   return jresult;
28329 }
28330
28331
28332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
28333   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28334   bool arg2 ;
28335
28336   arg1 = (Dali::RenderTask *)jarg1;
28337   arg2 = jarg2 ? true : false;
28338   {
28339     try {
28340       (arg1)->SetExclusive(arg2);
28341     } catch (std::out_of_range& e) {
28342       {
28343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28344       };
28345     } catch (std::exception& e) {
28346       {
28347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28348       };
28349     } catch (Dali::DaliException e) {
28350       {
28351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28352       };
28353     } catch (...) {
28354       {
28355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28356       };
28357     }
28358   }
28359
28360 }
28361
28362
28363 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
28364   unsigned int jresult ;
28365   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28366   bool result;
28367
28368   arg1 = (Dali::RenderTask *)jarg1;
28369   {
28370     try {
28371       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
28372     } catch (std::out_of_range& e) {
28373       {
28374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28375       };
28376     } catch (std::exception& e) {
28377       {
28378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28379       };
28380     } catch (Dali::DaliException e) {
28381       {
28382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28383       };
28384     } catch (...) {
28385       {
28386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28387       };
28388     }
28389   }
28390
28391   jresult = result;
28392   return jresult;
28393 }
28394
28395
28396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
28397   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28398   bool arg2 ;
28399
28400   arg1 = (Dali::RenderTask *)jarg1;
28401   arg2 = jarg2 ? true : false;
28402   {
28403     try {
28404       (arg1)->SetInputEnabled(arg2);
28405     } catch (std::out_of_range& e) {
28406       {
28407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28408       };
28409     } catch (std::exception& e) {
28410       {
28411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28412       };
28413     } catch (Dali::DaliException e) {
28414       {
28415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28416       };
28417     } catch (...) {
28418       {
28419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28420       };
28421     }
28422   }
28423
28424 }
28425
28426
28427 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
28428   unsigned int jresult ;
28429   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28430   bool result;
28431
28432   arg1 = (Dali::RenderTask *)jarg1;
28433   {
28434     try {
28435       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
28436     } catch (std::out_of_range& e) {
28437       {
28438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28439       };
28440     } catch (std::exception& e) {
28441       {
28442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28443       };
28444     } catch (Dali::DaliException e) {
28445       {
28446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28447       };
28448     } catch (...) {
28449       {
28450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28451       };
28452     }
28453   }
28454
28455   jresult = result;
28456   return jresult;
28457 }
28458
28459
28460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
28461   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28462   Dali::CameraActor arg2 ;
28463   Dali::CameraActor *argp2 ;
28464
28465   arg1 = (Dali::RenderTask *)jarg1;
28466   argp2 = (Dali::CameraActor *)jarg2;
28467   if (!argp2) {
28468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
28469     return ;
28470   }
28471   arg2 = *argp2;
28472   {
28473     try {
28474       (arg1)->SetCameraActor(arg2);
28475     } catch (std::out_of_range& e) {
28476       {
28477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28478       };
28479     } catch (std::exception& e) {
28480       {
28481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28482       };
28483     } catch (Dali::DaliException e) {
28484       {
28485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28486       };
28487     } catch (...) {
28488       {
28489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28490       };
28491     }
28492   }
28493
28494 }
28495
28496
28497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
28498   void * jresult ;
28499   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28500   Dali::CameraActor result;
28501
28502   arg1 = (Dali::RenderTask *)jarg1;
28503   {
28504     try {
28505       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
28506     } catch (std::out_of_range& e) {
28507       {
28508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28509       };
28510     } catch (std::exception& e) {
28511       {
28512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28513       };
28514     } catch (Dali::DaliException e) {
28515       {
28516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28517       };
28518     } catch (...) {
28519       {
28520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28521       };
28522     }
28523   }
28524
28525   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28526   return jresult;
28527 }
28528
28529
28530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
28531   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28532   Dali::FrameBufferImage arg2 ;
28533   Dali::FrameBufferImage *argp2 ;
28534
28535   arg1 = (Dali::RenderTask *)jarg1;
28536   argp2 = (Dali::FrameBufferImage *)jarg2;
28537   if (!argp2) {
28538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
28539     return ;
28540   }
28541   arg2 = *argp2;
28542   {
28543     try {
28544       (arg1)->SetTargetFrameBuffer(arg2);
28545     } catch (std::out_of_range& e) {
28546       {
28547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28548       };
28549     } catch (std::exception& e) {
28550       {
28551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28552       };
28553     } catch (Dali::DaliException e) {
28554       {
28555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28556       };
28557     } catch (...) {
28558       {
28559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28560       };
28561     }
28562   }
28563
28564 }
28565
28566
28567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
28568   void * jresult ;
28569   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28570   Dali::FrameBufferImage result;
28571
28572   arg1 = (Dali::RenderTask *)jarg1;
28573   {
28574     try {
28575       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
28576     } catch (std::out_of_range& e) {
28577       {
28578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28579       };
28580     } catch (std::exception& e) {
28581       {
28582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28583       };
28584     } catch (Dali::DaliException e) {
28585       {
28586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28587       };
28588     } catch (...) {
28589       {
28590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28591       };
28592     }
28593   }
28594
28595   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
28596   return jresult;
28597 }
28598
28599
28600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
28601   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28602   Dali::FrameBuffer arg2 ;
28603   Dali::FrameBuffer *argp2 ;
28604
28605   arg1 = (Dali::RenderTask *)jarg1;
28606   argp2 = (Dali::FrameBuffer *)jarg2;
28607   if (!argp2) {
28608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
28609     return ;
28610   }
28611   arg2 = *argp2;
28612   {
28613     try {
28614       (arg1)->SetFrameBuffer(arg2);
28615     } catch (std::out_of_range& e) {
28616       {
28617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28618       };
28619     } catch (std::exception& e) {
28620       {
28621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28622       };
28623     } catch (Dali::DaliException e) {
28624       {
28625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28626       };
28627     } catch (...) {
28628       {
28629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28630       };
28631     }
28632   }
28633
28634 }
28635
28636
28637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
28638   void * jresult ;
28639   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28640   Dali::FrameBuffer result;
28641
28642   arg1 = (Dali::RenderTask *)jarg1;
28643   {
28644     try {
28645       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
28646     } catch (std::out_of_range& e) {
28647       {
28648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28649       };
28650     } catch (std::exception& e) {
28651       {
28652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28653       };
28654     } catch (Dali::DaliException e) {
28655       {
28656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28657       };
28658     } catch (...) {
28659       {
28660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28661       };
28662     }
28663   }
28664
28665   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
28666   return jresult;
28667 }
28668
28669
28670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
28671   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28672   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
28673
28674   arg1 = (Dali::RenderTask *)jarg1;
28675   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
28676   {
28677     try {
28678       (arg1)->SetScreenToFrameBufferFunction(arg2);
28679     } catch (std::out_of_range& e) {
28680       {
28681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28682       };
28683     } catch (std::exception& e) {
28684       {
28685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28686       };
28687     } catch (Dali::DaliException e) {
28688       {
28689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28690       };
28691     } catch (...) {
28692       {
28693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28694       };
28695     }
28696   }
28697
28698 }
28699
28700
28701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
28702   void * jresult ;
28703   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28704   Dali::RenderTask::ScreenToFrameBufferFunction result;
28705
28706   arg1 = (Dali::RenderTask *)jarg1;
28707   {
28708     try {
28709       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
28710     } catch (std::out_of_range& e) {
28711       {
28712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28713       };
28714     } catch (std::exception& e) {
28715       {
28716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28717       };
28718     } catch (Dali::DaliException e) {
28719       {
28720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28721       };
28722     } catch (...) {
28723       {
28724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28725       };
28726     }
28727   }
28728
28729   jresult = (void *)result;
28730   return jresult;
28731 }
28732
28733
28734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
28735   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28736   Dali::Actor arg2 ;
28737   Dali::Actor *argp2 ;
28738
28739   arg1 = (Dali::RenderTask *)jarg1;
28740   argp2 = (Dali::Actor *)jarg2;
28741   if (!argp2) {
28742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28743     return ;
28744   }
28745   arg2 = *argp2;
28746   {
28747     try {
28748       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
28749     } catch (std::out_of_range& e) {
28750       {
28751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28752       };
28753     } catch (std::exception& e) {
28754       {
28755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28756       };
28757     } catch (Dali::DaliException e) {
28758       {
28759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28760       };
28761     } catch (...) {
28762       {
28763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28764       };
28765     }
28766   }
28767
28768 }
28769
28770
28771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
28772   void * jresult ;
28773   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28774   Dali::Actor result;
28775
28776   arg1 = (Dali::RenderTask *)jarg1;
28777   {
28778     try {
28779       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
28780     } catch (std::out_of_range& e) {
28781       {
28782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28783       };
28784     } catch (std::exception& e) {
28785       {
28786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28787       };
28788     } catch (Dali::DaliException e) {
28789       {
28790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28791       };
28792     } catch (...) {
28793       {
28794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28795       };
28796     }
28797   }
28798
28799   jresult = new Dali::Actor((const Dali::Actor &)result);
28800   return jresult;
28801 }
28802
28803
28804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
28805   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28806   Dali::Vector2 arg2 ;
28807   Dali::Vector2 *argp2 ;
28808
28809   arg1 = (Dali::RenderTask *)jarg1;
28810   argp2 = (Dali::Vector2 *)jarg2;
28811   if (!argp2) {
28812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28813     return ;
28814   }
28815   arg2 = *argp2;
28816   {
28817     try {
28818       (arg1)->SetViewportPosition(arg2);
28819     } catch (std::out_of_range& e) {
28820       {
28821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28822       };
28823     } catch (std::exception& e) {
28824       {
28825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28826       };
28827     } catch (Dali::DaliException e) {
28828       {
28829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28830       };
28831     } catch (...) {
28832       {
28833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28834       };
28835     }
28836   }
28837
28838 }
28839
28840
28841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
28842   void * jresult ;
28843   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28844   Dali::Vector2 result;
28845
28846   arg1 = (Dali::RenderTask *)jarg1;
28847   {
28848     try {
28849       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
28850     } catch (std::out_of_range& e) {
28851       {
28852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28853       };
28854     } catch (std::exception& e) {
28855       {
28856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28857       };
28858     } catch (Dali::DaliException e) {
28859       {
28860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28861       };
28862     } catch (...) {
28863       {
28864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28865       };
28866     }
28867   }
28868
28869   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28870   return jresult;
28871 }
28872
28873
28874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
28875   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28876   Dali::Vector2 arg2 ;
28877   Dali::Vector2 *argp2 ;
28878
28879   arg1 = (Dali::RenderTask *)jarg1;
28880   argp2 = (Dali::Vector2 *)jarg2;
28881   if (!argp2) {
28882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28883     return ;
28884   }
28885   arg2 = *argp2;
28886   {
28887     try {
28888       (arg1)->SetViewportSize(arg2);
28889     } catch (std::out_of_range& e) {
28890       {
28891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28892       };
28893     } catch (std::exception& e) {
28894       {
28895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28896       };
28897     } catch (Dali::DaliException e) {
28898       {
28899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28900       };
28901     } catch (...) {
28902       {
28903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28904       };
28905     }
28906   }
28907
28908 }
28909
28910
28911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
28912   void * jresult ;
28913   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28914   Dali::Vector2 result;
28915
28916   arg1 = (Dali::RenderTask *)jarg1;
28917   {
28918     try {
28919       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
28920     } catch (std::out_of_range& e) {
28921       {
28922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28923       };
28924     } catch (std::exception& e) {
28925       {
28926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28927       };
28928     } catch (Dali::DaliException e) {
28929       {
28930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28931       };
28932     } catch (...) {
28933       {
28934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28935       };
28936     }
28937   }
28938
28939   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28940   return jresult;
28941 }
28942
28943
28944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
28945   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28946   Dali::Viewport arg2 ;
28947   Dali::Viewport *argp2 ;
28948
28949   arg1 = (Dali::RenderTask *)jarg1;
28950   argp2 = (Dali::Viewport *)jarg2;
28951   if (!argp2) {
28952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
28953     return ;
28954   }
28955   arg2 = *argp2;
28956   {
28957     try {
28958       (arg1)->SetViewport(arg2);
28959     } catch (std::out_of_range& e) {
28960       {
28961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28962       };
28963     } catch (std::exception& e) {
28964       {
28965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28966       };
28967     } catch (Dali::DaliException e) {
28968       {
28969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28970       };
28971     } catch (...) {
28972       {
28973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28974       };
28975     }
28976   }
28977
28978 }
28979
28980
28981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
28982   void * jresult ;
28983   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28984   Dali::Viewport result;
28985
28986   arg1 = (Dali::RenderTask *)jarg1;
28987   {
28988     try {
28989       result = ((Dali::RenderTask const *)arg1)->GetViewport();
28990     } catch (std::out_of_range& e) {
28991       {
28992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28993       };
28994     } catch (std::exception& e) {
28995       {
28996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28997       };
28998     } catch (Dali::DaliException e) {
28999       {
29000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29001       };
29002     } catch (...) {
29003       {
29004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29005       };
29006     }
29007   }
29008
29009   jresult = new Dali::Viewport((const Dali::Viewport &)result);
29010   return jresult;
29011 }
29012
29013
29014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
29015   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29016   Dali::Vector4 *arg2 = 0 ;
29017
29018   arg1 = (Dali::RenderTask *)jarg1;
29019   arg2 = (Dali::Vector4 *)jarg2;
29020   if (!arg2) {
29021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
29022     return ;
29023   }
29024   {
29025     try {
29026       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
29027     } catch (std::out_of_range& e) {
29028       {
29029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29030       };
29031     } catch (std::exception& e) {
29032       {
29033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29034       };
29035     } catch (Dali::DaliException e) {
29036       {
29037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29038       };
29039     } catch (...) {
29040       {
29041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29042       };
29043     }
29044   }
29045
29046 }
29047
29048
29049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
29050   void * jresult ;
29051   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29052   Dali::Vector4 result;
29053
29054   arg1 = (Dali::RenderTask *)jarg1;
29055   {
29056     try {
29057       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
29058     } catch (std::out_of_range& e) {
29059       {
29060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29061       };
29062     } catch (std::exception& e) {
29063       {
29064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29065       };
29066     } catch (Dali::DaliException e) {
29067       {
29068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29069       };
29070     } catch (...) {
29071       {
29072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29073       };
29074     }
29075   }
29076
29077   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
29078   return jresult;
29079 }
29080
29081
29082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
29083   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29084   bool arg2 ;
29085
29086   arg1 = (Dali::RenderTask *)jarg1;
29087   arg2 = jarg2 ? true : false;
29088   {
29089     try {
29090       (arg1)->SetClearEnabled(arg2);
29091     } catch (std::out_of_range& e) {
29092       {
29093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29094       };
29095     } catch (std::exception& e) {
29096       {
29097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29098       };
29099     } catch (Dali::DaliException e) {
29100       {
29101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29102       };
29103     } catch (...) {
29104       {
29105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29106       };
29107     }
29108   }
29109
29110 }
29111
29112
29113 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
29114   unsigned int jresult ;
29115   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29116   bool result;
29117
29118   arg1 = (Dali::RenderTask *)jarg1;
29119   {
29120     try {
29121       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
29122     } catch (std::out_of_range& e) {
29123       {
29124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29125       };
29126     } catch (std::exception& e) {
29127       {
29128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29129       };
29130     } catch (Dali::DaliException e) {
29131       {
29132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29133       };
29134     } catch (...) {
29135       {
29136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29137       };
29138     }
29139   }
29140
29141   jresult = result;
29142   return jresult;
29143 }
29144
29145
29146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
29147   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29148   bool arg2 ;
29149
29150   arg1 = (Dali::RenderTask *)jarg1;
29151   arg2 = jarg2 ? true : false;
29152   {
29153     try {
29154       (arg1)->SetCullMode(arg2);
29155     } catch (std::out_of_range& e) {
29156       {
29157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29158       };
29159     } catch (std::exception& e) {
29160       {
29161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29162       };
29163     } catch (Dali::DaliException e) {
29164       {
29165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29166       };
29167     } catch (...) {
29168       {
29169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29170       };
29171     }
29172   }
29173
29174 }
29175
29176
29177 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
29178   unsigned int jresult ;
29179   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29180   bool result;
29181
29182   arg1 = (Dali::RenderTask *)jarg1;
29183   {
29184     try {
29185       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
29186     } catch (std::out_of_range& e) {
29187       {
29188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29189       };
29190     } catch (std::exception& e) {
29191       {
29192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29193       };
29194     } catch (Dali::DaliException e) {
29195       {
29196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29197       };
29198     } catch (...) {
29199       {
29200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29201       };
29202     }
29203   }
29204
29205   jresult = result;
29206   return jresult;
29207 }
29208
29209
29210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
29211   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29212   unsigned int arg2 ;
29213
29214   arg1 = (Dali::RenderTask *)jarg1;
29215   arg2 = (unsigned int)jarg2;
29216   {
29217     try {
29218       (arg1)->SetRefreshRate(arg2);
29219     } catch (std::out_of_range& e) {
29220       {
29221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29222       };
29223     } catch (std::exception& e) {
29224       {
29225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29226       };
29227     } catch (Dali::DaliException e) {
29228       {
29229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29230       };
29231     } catch (...) {
29232       {
29233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29234       };
29235     }
29236   }
29237
29238 }
29239
29240
29241 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
29242   unsigned int jresult ;
29243   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29244   unsigned int result;
29245
29246   arg1 = (Dali::RenderTask *)jarg1;
29247   {
29248     try {
29249       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
29250     } catch (std::out_of_range& e) {
29251       {
29252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29253       };
29254     } catch (std::exception& e) {
29255       {
29256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29257       };
29258     } catch (Dali::DaliException e) {
29259       {
29260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29261       };
29262     } catch (...) {
29263       {
29264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29265       };
29266     }
29267   }
29268
29269   jresult = result;
29270   return jresult;
29271 }
29272
29273
29274 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
29275   unsigned int jresult ;
29276   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29277   Dali::Vector3 *arg2 = 0 ;
29278   float *arg3 = 0 ;
29279   float *arg4 = 0 ;
29280   bool result;
29281
29282   arg1 = (Dali::RenderTask *)jarg1;
29283   arg2 = (Dali::Vector3 *)jarg2;
29284   if (!arg2) {
29285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29286     return 0;
29287   }
29288   arg3 = (float *)jarg3;
29289   arg4 = (float *)jarg4;
29290   {
29291     try {
29292       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
29293     } catch (std::out_of_range& e) {
29294       {
29295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29296       };
29297     } catch (std::exception& e) {
29298       {
29299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29300       };
29301     } catch (Dali::DaliException e) {
29302       {
29303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29304       };
29305     } catch (...) {
29306       {
29307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29308       };
29309     }
29310   }
29311
29312   jresult = result;
29313   return jresult;
29314 }
29315
29316
29317 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
29318   unsigned int jresult ;
29319   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29320   Dali::Actor arg2 ;
29321   float arg3 ;
29322   float arg4 ;
29323   float *arg5 = 0 ;
29324   float *arg6 = 0 ;
29325   Dali::Actor *argp2 ;
29326   bool result;
29327
29328   arg1 = (Dali::RenderTask *)jarg1;
29329   argp2 = (Dali::Actor *)jarg2;
29330   if (!argp2) {
29331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29332     return 0;
29333   }
29334   arg2 = *argp2;
29335   arg3 = (float)jarg3;
29336   arg4 = (float)jarg4;
29337   arg5 = (float *)jarg5;
29338   arg6 = (float *)jarg6;
29339   {
29340     try {
29341       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
29342     } catch (std::out_of_range& e) {
29343       {
29344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29345       };
29346     } catch (std::exception& e) {
29347       {
29348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29349       };
29350     } catch (Dali::DaliException e) {
29351       {
29352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29353       };
29354     } catch (...) {
29355       {
29356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29357       };
29358     }
29359   }
29360
29361   jresult = result;
29362   return jresult;
29363 }
29364
29365
29366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
29367   void * jresult ;
29368   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29369   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
29370
29371   arg1 = (Dali::RenderTask *)jarg1;
29372   {
29373     try {
29374       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
29375     } catch (std::out_of_range& e) {
29376       {
29377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29378       };
29379     } catch (std::exception& e) {
29380       {
29381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29382       };
29383     } catch (Dali::DaliException e) {
29384       {
29385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29386       };
29387     } catch (...) {
29388       {
29389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29390       };
29391     }
29392   }
29393
29394   jresult = (void *)result;
29395   return jresult;
29396 }
29397
29398
29399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
29400   void * jresult ;
29401   int arg1 ;
29402   Dali::TouchPoint::State arg2 ;
29403   float arg3 ;
29404   float arg4 ;
29405   Dali::TouchPoint *result = 0 ;
29406
29407   arg1 = (int)jarg1;
29408   arg2 = (Dali::TouchPoint::State)jarg2;
29409   arg3 = (float)jarg3;
29410   arg4 = (float)jarg4;
29411   {
29412     try {
29413       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
29414     } catch (std::out_of_range& e) {
29415       {
29416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29417       };
29418     } catch (std::exception& e) {
29419       {
29420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29421       };
29422     } catch (Dali::DaliException e) {
29423       {
29424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29425       };
29426     } catch (...) {
29427       {
29428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29429       };
29430     }
29431   }
29432
29433   jresult = (void *)result;
29434   return jresult;
29435 }
29436
29437
29438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
29439   void * jresult ;
29440   int arg1 ;
29441   Dali::TouchPoint::State arg2 ;
29442   float arg3 ;
29443   float arg4 ;
29444   float arg5 ;
29445   float arg6 ;
29446   Dali::TouchPoint *result = 0 ;
29447
29448   arg1 = (int)jarg1;
29449   arg2 = (Dali::TouchPoint::State)jarg2;
29450   arg3 = (float)jarg3;
29451   arg4 = (float)jarg4;
29452   arg5 = (float)jarg5;
29453   arg6 = (float)jarg6;
29454   {
29455     try {
29456       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
29457     } catch (std::out_of_range& e) {
29458       {
29459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29460       };
29461     } catch (std::exception& e) {
29462       {
29463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29464       };
29465     } catch (Dali::DaliException e) {
29466       {
29467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29468       };
29469     } catch (...) {
29470       {
29471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29472       };
29473     }
29474   }
29475
29476   jresult = (void *)result;
29477   return jresult;
29478 }
29479
29480
29481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
29482   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29483
29484   arg1 = (Dali::TouchPoint *)jarg1;
29485   {
29486     try {
29487       delete arg1;
29488     } catch (std::out_of_range& e) {
29489       {
29490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29491       };
29492     } catch (std::exception& e) {
29493       {
29494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29495       };
29496     } catch (Dali::DaliException e) {
29497       {
29498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29499       };
29500     } catch (...) {
29501       {
29502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29503       };
29504     }
29505   }
29506
29507 }
29508
29509
29510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
29511   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29512   int arg2 ;
29513
29514   arg1 = (Dali::TouchPoint *)jarg1;
29515   arg2 = (int)jarg2;
29516   if (arg1) (arg1)->deviceId = arg2;
29517 }
29518
29519
29520 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
29521   int jresult ;
29522   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29523   int result;
29524
29525   arg1 = (Dali::TouchPoint *)jarg1;
29526   result = (int) ((arg1)->deviceId);
29527   jresult = result;
29528   return jresult;
29529 }
29530
29531
29532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
29533   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29534   Dali::TouchPoint::State arg2 ;
29535
29536   arg1 = (Dali::TouchPoint *)jarg1;
29537   arg2 = (Dali::TouchPoint::State)jarg2;
29538   if (arg1) (arg1)->state = arg2;
29539 }
29540
29541
29542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
29543   int jresult ;
29544   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29545   Dali::TouchPoint::State result;
29546
29547   arg1 = (Dali::TouchPoint *)jarg1;
29548   result = (Dali::TouchPoint::State) ((arg1)->state);
29549   jresult = (int)result;
29550   return jresult;
29551 }
29552
29553
29554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
29555   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29556   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
29557
29558   arg1 = (Dali::TouchPoint *)jarg1;
29559   arg2 = (Dali::Actor *)jarg2;
29560   if (arg1) (arg1)->hitActor = *arg2;
29561 }
29562
29563
29564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
29565   void * jresult ;
29566   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29567   Dali::Actor *result = 0 ;
29568
29569   arg1 = (Dali::TouchPoint *)jarg1;
29570   result = (Dali::Actor *)& ((arg1)->hitActor);
29571   jresult = (void *)result;
29572   return jresult;
29573 }
29574
29575
29576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
29577   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29578   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29579
29580   arg1 = (Dali::TouchPoint *)jarg1;
29581   arg2 = (Dali::Vector2 *)jarg2;
29582   if (arg1) (arg1)->local = *arg2;
29583 }
29584
29585
29586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
29587   void * jresult ;
29588   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29589   Dali::Vector2 *result = 0 ;
29590
29591   arg1 = (Dali::TouchPoint *)jarg1;
29592   result = (Dali::Vector2 *)& ((arg1)->local);
29593   jresult = (void *)result;
29594   return jresult;
29595 }
29596
29597
29598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
29599   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29600   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29601
29602   arg1 = (Dali::TouchPoint *)jarg1;
29603   arg2 = (Dali::Vector2 *)jarg2;
29604   if (arg1) (arg1)->screen = *arg2;
29605 }
29606
29607
29608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
29609   void * jresult ;
29610   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29611   Dali::Vector2 *result = 0 ;
29612
29613   arg1 = (Dali::TouchPoint *)jarg1;
29614   result = (Dali::Vector2 *)& ((arg1)->screen);
29615   jresult = (void *)result;
29616   return jresult;
29617 }
29618
29619
29620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
29621   void * jresult ;
29622   Dali::TouchData *result = 0 ;
29623
29624   {
29625     try {
29626       result = (Dali::TouchData *)new Dali::TouchData();
29627     } catch (std::out_of_range& e) {
29628       {
29629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29630       };
29631     } catch (std::exception& e) {
29632       {
29633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29634       };
29635     } catch (Dali::DaliException e) {
29636       {
29637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29638       };
29639     } catch (...) {
29640       {
29641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29642       };
29643     }
29644   }
29645
29646   jresult = (void *)result;
29647   return jresult;
29648 }
29649
29650
29651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
29652   void * jresult ;
29653   Dali::TouchData *arg1 = 0 ;
29654   Dali::TouchData *result = 0 ;
29655
29656   arg1 = (Dali::TouchData *)jarg1;
29657   if (!arg1) {
29658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29659     return 0;
29660   }
29661   {
29662     try {
29663       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
29664     } catch (std::out_of_range& e) {
29665       {
29666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29667       };
29668     } catch (std::exception& e) {
29669       {
29670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29671       };
29672     } catch (Dali::DaliException e) {
29673       {
29674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29675       };
29676     } catch (...) {
29677       {
29678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29679       };
29680     }
29681   }
29682
29683   jresult = (void *)result;
29684   return jresult;
29685 }
29686
29687
29688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
29689   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29690
29691   arg1 = (Dali::TouchData *)jarg1;
29692   {
29693     try {
29694       delete arg1;
29695     } catch (std::out_of_range& e) {
29696       {
29697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29698       };
29699     } catch (std::exception& e) {
29700       {
29701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29702       };
29703     } catch (Dali::DaliException e) {
29704       {
29705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29706       };
29707     } catch (...) {
29708       {
29709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29710       };
29711     }
29712   }
29713
29714 }
29715
29716
29717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
29718   void * jresult ;
29719   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29720   Dali::TouchData *arg2 = 0 ;
29721   Dali::TouchData *result = 0 ;
29722
29723   arg1 = (Dali::TouchData *)jarg1;
29724   arg2 = (Dali::TouchData *)jarg2;
29725   if (!arg2) {
29726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29727     return 0;
29728   }
29729   {
29730     try {
29731       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
29732     } catch (std::out_of_range& e) {
29733       {
29734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29735       };
29736     } catch (std::exception& e) {
29737       {
29738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29739       };
29740     } catch (Dali::DaliException e) {
29741       {
29742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29743       };
29744     } catch (...) {
29745       {
29746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29747       };
29748     }
29749   }
29750
29751   jresult = (void *)result;
29752   return jresult;
29753 }
29754
29755
29756 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
29757   unsigned long jresult ;
29758   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29759   unsigned long result;
29760
29761   arg1 = (Dali::TouchData *)jarg1;
29762   {
29763     try {
29764       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
29765     } catch (std::out_of_range& e) {
29766       {
29767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29768       };
29769     } catch (std::exception& e) {
29770       {
29771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29772       };
29773     } catch (Dali::DaliException e) {
29774       {
29775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29776       };
29777     } catch (...) {
29778       {
29779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29780       };
29781     }
29782   }
29783
29784   jresult = (unsigned long)result;
29785   return jresult;
29786 }
29787
29788
29789 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
29790   unsigned long jresult ;
29791   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29792   std::size_t result;
29793
29794   arg1 = (Dali::TouchData *)jarg1;
29795   {
29796     try {
29797       result = ((Dali::TouchData const *)arg1)->GetPointCount();
29798     } catch (std::out_of_range& e) {
29799       {
29800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29801       };
29802     } catch (std::exception& e) {
29803       {
29804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29805       };
29806     } catch (Dali::DaliException e) {
29807       {
29808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29809       };
29810     } catch (...) {
29811       {
29812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29813       };
29814     }
29815   }
29816
29817   jresult = (unsigned long)result;
29818   return jresult;
29819 }
29820
29821
29822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
29823   int jresult ;
29824   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29825   std::size_t arg2 ;
29826   int32_t result;
29827
29828   arg1 = (Dali::TouchData *)jarg1;
29829   arg2 = (std::size_t)jarg2;
29830   {
29831     try {
29832       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
29833     } catch (std::out_of_range& e) {
29834       {
29835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29836       };
29837     } catch (std::exception& e) {
29838       {
29839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29840       };
29841     } catch (Dali::DaliException e) {
29842       {
29843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29844       };
29845     } catch (...) {
29846       {
29847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29848       };
29849     }
29850   }
29851
29852   jresult = result;
29853   return jresult;
29854 }
29855
29856
29857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
29858   int jresult ;
29859   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29860   std::size_t arg2 ;
29861   Dali::PointState::Type result;
29862
29863   arg1 = (Dali::TouchData *)jarg1;
29864   arg2 = (std::size_t)jarg2;
29865   {
29866     try {
29867       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
29868     } catch (std::out_of_range& e) {
29869       {
29870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29871       };
29872     } catch (std::exception& e) {
29873       {
29874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29875       };
29876     } catch (Dali::DaliException e) {
29877       {
29878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29879       };
29880     } catch (...) {
29881       {
29882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29883       };
29884     }
29885   }
29886
29887   jresult = (int)result;
29888   return jresult;
29889 }
29890
29891
29892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
29893   void * jresult ;
29894   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29895   std::size_t arg2 ;
29896   Dali::Actor result;
29897
29898   arg1 = (Dali::TouchData *)jarg1;
29899   arg2 = (std::size_t)jarg2;
29900   {
29901     try {
29902       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
29903     } catch (std::out_of_range& e) {
29904       {
29905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29906       };
29907     } catch (std::exception& e) {
29908       {
29909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29910       };
29911     } catch (Dali::DaliException e) {
29912       {
29913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29914       };
29915     } catch (...) {
29916       {
29917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29918       };
29919     }
29920   }
29921
29922   jresult = new Dali::Actor((const Dali::Actor &)result);
29923   return jresult;
29924 }
29925
29926
29927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
29928   void * jresult ;
29929   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29930   std::size_t arg2 ;
29931   Dali::Vector2 *result = 0 ;
29932
29933   arg1 = (Dali::TouchData *)jarg1;
29934   arg2 = (std::size_t)jarg2;
29935   {
29936     try {
29937       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
29938     } catch (std::out_of_range& e) {
29939       {
29940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29941       };
29942     } catch (std::exception& e) {
29943       {
29944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29945       };
29946     } catch (Dali::DaliException e) {
29947       {
29948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29949       };
29950     } catch (...) {
29951       {
29952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29953       };
29954     }
29955   }
29956
29957   jresult = (void *)result;
29958   return jresult;
29959 }
29960
29961
29962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
29963   void * jresult ;
29964   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29965   std::size_t arg2 ;
29966   Dali::Vector2 *result = 0 ;
29967
29968   arg1 = (Dali::TouchData *)jarg1;
29969   arg2 = (std::size_t)jarg2;
29970   {
29971     try {
29972       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
29973     } catch (std::out_of_range& e) {
29974       {
29975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29976       };
29977     } catch (std::exception& e) {
29978       {
29979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29980       };
29981     } catch (Dali::DaliException e) {
29982       {
29983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29984       };
29985     } catch (...) {
29986       {
29987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29988       };
29989     }
29990   }
29991
29992   jresult = (void *)result;
29993   return jresult;
29994 }
29995
29996
29997 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
29998   float jresult ;
29999   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30000   std::size_t arg2 ;
30001   float result;
30002
30003   arg1 = (Dali::TouchData *)jarg1;
30004   arg2 = (std::size_t)jarg2;
30005   {
30006     try {
30007       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
30008     } catch (std::out_of_range& e) {
30009       {
30010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30011       };
30012     } catch (std::exception& e) {
30013       {
30014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30015       };
30016     } catch (Dali::DaliException e) {
30017       {
30018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30019       };
30020     } catch (...) {
30021       {
30022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30023       };
30024     }
30025   }
30026
30027   jresult = result;
30028   return jresult;
30029 }
30030
30031
30032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
30033   void * jresult ;
30034   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30035   std::size_t arg2 ;
30036   Dali::Vector2 *result = 0 ;
30037
30038   arg1 = (Dali::TouchData *)jarg1;
30039   arg2 = (std::size_t)jarg2;
30040   {
30041     try {
30042       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
30043     } catch (std::out_of_range& e) {
30044       {
30045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30046       };
30047     } catch (std::exception& e) {
30048       {
30049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30050       };
30051     } catch (Dali::DaliException e) {
30052       {
30053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30054       };
30055     } catch (...) {
30056       {
30057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30058       };
30059     }
30060   }
30061
30062   jresult = (void *)result;
30063   return jresult;
30064 }
30065
30066
30067 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
30068   float jresult ;
30069   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30070   std::size_t arg2 ;
30071   float result;
30072
30073   arg1 = (Dali::TouchData *)jarg1;
30074   arg2 = (std::size_t)jarg2;
30075   {
30076     try {
30077       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
30078     } catch (std::out_of_range& e) {
30079       {
30080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30081       };
30082     } catch (std::exception& e) {
30083       {
30084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30085       };
30086     } catch (Dali::DaliException e) {
30087       {
30088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30089       };
30090     } catch (...) {
30091       {
30092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30093       };
30094     }
30095   }
30096
30097   jresult = result;
30098   return jresult;
30099 }
30100
30101
30102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
30103   void * jresult ;
30104   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30105   std::size_t arg2 ;
30106   Dali::Degree result;
30107
30108   arg1 = (Dali::TouchData *)jarg1;
30109   arg2 = (std::size_t)jarg2;
30110   {
30111     try {
30112       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
30113     } catch (std::out_of_range& e) {
30114       {
30115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30116       };
30117     } catch (std::exception& e) {
30118       {
30119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30120       };
30121     } catch (Dali::DaliException e) {
30122       {
30123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30124       };
30125     } catch (...) {
30126       {
30127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30128       };
30129     }
30130   }
30131
30132   jresult = new Dali::Degree((const Dali::Degree &)result);
30133   return jresult;
30134 }
30135
30136
30137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
30138   void * jresult ;
30139   Dali::GestureDetector *result = 0 ;
30140
30141   {
30142     try {
30143       result = (Dali::GestureDetector *)new Dali::GestureDetector();
30144     } catch (std::out_of_range& e) {
30145       {
30146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30147       };
30148     } catch (std::exception& e) {
30149       {
30150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30151       };
30152     } catch (Dali::DaliException e) {
30153       {
30154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30155       };
30156     } catch (...) {
30157       {
30158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30159       };
30160     }
30161   }
30162
30163   jresult = (void *)result;
30164   return jresult;
30165 }
30166
30167
30168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
30169   void * jresult ;
30170   Dali::BaseHandle arg1 ;
30171   Dali::BaseHandle *argp1 ;
30172   Dali::GestureDetector result;
30173
30174   argp1 = (Dali::BaseHandle *)jarg1;
30175   if (!argp1) {
30176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30177     return 0;
30178   }
30179   arg1 = *argp1;
30180   {
30181     try {
30182       result = Dali::GestureDetector::DownCast(arg1);
30183     } catch (std::out_of_range& e) {
30184       {
30185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30186       };
30187     } catch (std::exception& e) {
30188       {
30189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30190       };
30191     } catch (Dali::DaliException e) {
30192       {
30193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30194       };
30195     } catch (...) {
30196       {
30197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30198       };
30199     }
30200   }
30201
30202   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
30203   return jresult;
30204 }
30205
30206
30207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
30208   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30209
30210   arg1 = (Dali::GestureDetector *)jarg1;
30211   {
30212     try {
30213       delete arg1;
30214     } catch (std::out_of_range& e) {
30215       {
30216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30217       };
30218     } catch (std::exception& e) {
30219       {
30220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30221       };
30222     } catch (Dali::DaliException e) {
30223       {
30224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30225       };
30226     } catch (...) {
30227       {
30228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30229       };
30230     }
30231   }
30232
30233 }
30234
30235
30236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
30237   void * jresult ;
30238   Dali::GestureDetector *arg1 = 0 ;
30239   Dali::GestureDetector *result = 0 ;
30240
30241   arg1 = (Dali::GestureDetector *)jarg1;
30242   if (!arg1) {
30243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30244     return 0;
30245   }
30246   {
30247     try {
30248       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
30249     } catch (std::out_of_range& e) {
30250       {
30251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30252       };
30253     } catch (std::exception& e) {
30254       {
30255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30256       };
30257     } catch (Dali::DaliException e) {
30258       {
30259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30260       };
30261     } catch (...) {
30262       {
30263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30264       };
30265     }
30266   }
30267
30268   jresult = (void *)result;
30269   return jresult;
30270 }
30271
30272
30273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
30274   void * jresult ;
30275   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30276   Dali::GestureDetector *arg2 = 0 ;
30277   Dali::GestureDetector *result = 0 ;
30278
30279   arg1 = (Dali::GestureDetector *)jarg1;
30280   arg2 = (Dali::GestureDetector *)jarg2;
30281   if (!arg2) {
30282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30283     return 0;
30284   }
30285   {
30286     try {
30287       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
30288     } catch (std::out_of_range& e) {
30289       {
30290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30291       };
30292     } catch (std::exception& e) {
30293       {
30294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30295       };
30296     } catch (Dali::DaliException e) {
30297       {
30298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30299       };
30300     } catch (...) {
30301       {
30302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30303       };
30304     }
30305   }
30306
30307   jresult = (void *)result;
30308   return jresult;
30309 }
30310
30311
30312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
30313   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30314   Dali::Actor arg2 ;
30315   Dali::Actor *argp2 ;
30316
30317   arg1 = (Dali::GestureDetector *)jarg1;
30318   argp2 = (Dali::Actor *)jarg2;
30319   if (!argp2) {
30320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30321     return ;
30322   }
30323   arg2 = *argp2;
30324   {
30325     try {
30326       (arg1)->Attach(arg2);
30327     } catch (std::out_of_range& e) {
30328       {
30329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30330       };
30331     } catch (std::exception& e) {
30332       {
30333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30334       };
30335     } catch (Dali::DaliException e) {
30336       {
30337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30338       };
30339     } catch (...) {
30340       {
30341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30342       };
30343     }
30344   }
30345
30346 }
30347
30348
30349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
30350   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30351   Dali::Actor arg2 ;
30352   Dali::Actor *argp2 ;
30353
30354   arg1 = (Dali::GestureDetector *)jarg1;
30355   argp2 = (Dali::Actor *)jarg2;
30356   if (!argp2) {
30357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30358     return ;
30359   }
30360   arg2 = *argp2;
30361   {
30362     try {
30363       (arg1)->Detach(arg2);
30364     } catch (std::out_of_range& e) {
30365       {
30366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30367       };
30368     } catch (std::exception& e) {
30369       {
30370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30371       };
30372     } catch (Dali::DaliException e) {
30373       {
30374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30375       };
30376     } catch (...) {
30377       {
30378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30379       };
30380     }
30381   }
30382
30383 }
30384
30385
30386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
30387   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30388
30389   arg1 = (Dali::GestureDetector *)jarg1;
30390   {
30391     try {
30392       (arg1)->DetachAll();
30393     } catch (std::out_of_range& e) {
30394       {
30395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30396       };
30397     } catch (std::exception& e) {
30398       {
30399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30400       };
30401     } catch (Dali::DaliException e) {
30402       {
30403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30404       };
30405     } catch (...) {
30406       {
30407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30408       };
30409     }
30410   }
30411
30412 }
30413
30414
30415 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
30416   unsigned long jresult ;
30417   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30418   size_t result;
30419
30420   arg1 = (Dali::GestureDetector *)jarg1;
30421   {
30422     try {
30423       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
30424     } catch (std::out_of_range& e) {
30425       {
30426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30427       };
30428     } catch (std::exception& e) {
30429       {
30430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30431       };
30432     } catch (Dali::DaliException e) {
30433       {
30434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30435       };
30436     } catch (...) {
30437       {
30438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30439       };
30440     }
30441   }
30442
30443   jresult = (unsigned long)result;
30444   return jresult;
30445 }
30446
30447
30448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
30449   void * jresult ;
30450   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30451   size_t arg2 ;
30452   Dali::Actor result;
30453
30454   arg1 = (Dali::GestureDetector *)jarg1;
30455   arg2 = (size_t)jarg2;
30456   {
30457     try {
30458       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
30459     } catch (std::out_of_range& e) {
30460       {
30461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30462       };
30463     } catch (std::exception& e) {
30464       {
30465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30466       };
30467     } catch (Dali::DaliException e) {
30468       {
30469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30470       };
30471     } catch (...) {
30472       {
30473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30474       };
30475     }
30476   }
30477
30478   jresult = new Dali::Actor((const Dali::Actor &)result);
30479   return jresult;
30480 }
30481
30482
30483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
30484   void * jresult ;
30485   Dali::Gesture *arg1 = 0 ;
30486   Dali::Gesture *result = 0 ;
30487
30488   arg1 = (Dali::Gesture *)jarg1;
30489   if (!arg1) {
30490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30491     return 0;
30492   }
30493   {
30494     try {
30495       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
30496     } catch (std::out_of_range& e) {
30497       {
30498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30499       };
30500     } catch (std::exception& e) {
30501       {
30502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30503       };
30504     } catch (Dali::DaliException e) {
30505       {
30506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30507       };
30508     } catch (...) {
30509       {
30510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30511       };
30512     }
30513   }
30514
30515   jresult = (void *)result;
30516   return jresult;
30517 }
30518
30519
30520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
30521   void * jresult ;
30522   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30523   Dali::Gesture *arg2 = 0 ;
30524   Dali::Gesture *result = 0 ;
30525
30526   arg1 = (Dali::Gesture *)jarg1;
30527   arg2 = (Dali::Gesture *)jarg2;
30528   if (!arg2) {
30529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30530     return 0;
30531   }
30532   {
30533     try {
30534       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
30535     } catch (std::out_of_range& e) {
30536       {
30537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30538       };
30539     } catch (std::exception& e) {
30540       {
30541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30542       };
30543     } catch (Dali::DaliException e) {
30544       {
30545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30546       };
30547     } catch (...) {
30548       {
30549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30550       };
30551     }
30552   }
30553
30554   jresult = (void *)result;
30555   return jresult;
30556 }
30557
30558
30559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
30560   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30561
30562   arg1 = (Dali::Gesture *)jarg1;
30563   {
30564     try {
30565       delete arg1;
30566     } catch (std::out_of_range& e) {
30567       {
30568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30569       };
30570     } catch (std::exception& e) {
30571       {
30572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30573       };
30574     } catch (Dali::DaliException e) {
30575       {
30576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30577       };
30578     } catch (...) {
30579       {
30580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30581       };
30582     }
30583   }
30584
30585 }
30586
30587
30588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
30589   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30590   Dali::Gesture::Type arg2 ;
30591
30592   arg1 = (Dali::Gesture *)jarg1;
30593   arg2 = (Dali::Gesture::Type)jarg2;
30594   if (arg1) (arg1)->type = arg2;
30595 }
30596
30597
30598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
30599   int jresult ;
30600   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30601   Dali::Gesture::Type result;
30602
30603   arg1 = (Dali::Gesture *)jarg1;
30604   result = (Dali::Gesture::Type) ((arg1)->type);
30605   jresult = (int)result;
30606   return jresult;
30607 }
30608
30609
30610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
30611   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30612   Dali::Gesture::State arg2 ;
30613
30614   arg1 = (Dali::Gesture *)jarg1;
30615   arg2 = (Dali::Gesture::State)jarg2;
30616   if (arg1) (arg1)->state = arg2;
30617 }
30618
30619
30620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
30621   int jresult ;
30622   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30623   Dali::Gesture::State result;
30624
30625   arg1 = (Dali::Gesture *)jarg1;
30626   result = (Dali::Gesture::State) ((arg1)->state);
30627   jresult = (int)result;
30628   return jresult;
30629 }
30630
30631
30632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
30633   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30634   unsigned int arg2 ;
30635
30636   arg1 = (Dali::Gesture *)jarg1;
30637   arg2 = (unsigned int)jarg2;
30638   if (arg1) (arg1)->time = arg2;
30639 }
30640
30641
30642 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
30643   unsigned int jresult ;
30644   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30645   unsigned int result;
30646
30647   arg1 = (Dali::Gesture *)jarg1;
30648   result = (unsigned int) ((arg1)->time);
30649   jresult = result;
30650   return jresult;
30651 }
30652
30653
30654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
30655   void * jresult ;
30656   Dali::HoverEvent *result = 0 ;
30657
30658   {
30659     try {
30660       result = (Dali::HoverEvent *)new Dali::HoverEvent();
30661     } catch (std::out_of_range& e) {
30662       {
30663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30664       };
30665     } catch (std::exception& e) {
30666       {
30667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30668       };
30669     } catch (Dali::DaliException e) {
30670       {
30671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30672       };
30673     } catch (...) {
30674       {
30675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30676       };
30677     }
30678   }
30679
30680   jresult = (void *)result;
30681   return jresult;
30682 }
30683
30684
30685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
30686   void * jresult ;
30687   unsigned long arg1 ;
30688   Dali::HoverEvent *result = 0 ;
30689
30690   arg1 = (unsigned long)jarg1;
30691   {
30692     try {
30693       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
30694     } catch (std::out_of_range& e) {
30695       {
30696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30697       };
30698     } catch (std::exception& e) {
30699       {
30700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30701       };
30702     } catch (Dali::DaliException e) {
30703       {
30704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30705       };
30706     } catch (...) {
30707       {
30708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30709       };
30710     }
30711   }
30712
30713   jresult = (void *)result;
30714   return jresult;
30715 }
30716
30717
30718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
30719   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30720
30721   arg1 = (Dali::HoverEvent *)jarg1;
30722   {
30723     try {
30724       delete arg1;
30725     } catch (std::out_of_range& e) {
30726       {
30727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30728       };
30729     } catch (std::exception& e) {
30730       {
30731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30732       };
30733     } catch (Dali::DaliException e) {
30734       {
30735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30736       };
30737     } catch (...) {
30738       {
30739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30740       };
30741     }
30742   }
30743
30744 }
30745
30746
30747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
30748   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30749   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
30750
30751   arg1 = (Dali::HoverEvent *)jarg1;
30752   arg2 = (Dali::TouchPointContainer *)jarg2;
30753   if (arg1) (arg1)->points = *arg2;
30754 }
30755
30756
30757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
30758   void * jresult ;
30759   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30760   Dali::TouchPointContainer *result = 0 ;
30761
30762   arg1 = (Dali::HoverEvent *)jarg1;
30763   result = (Dali::TouchPointContainer *)& ((arg1)->points);
30764   jresult = (void *)result;
30765   return jresult;
30766 }
30767
30768
30769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
30770   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30771   unsigned long arg2 ;
30772
30773   arg1 = (Dali::HoverEvent *)jarg1;
30774   arg2 = (unsigned long)jarg2;
30775   if (arg1) (arg1)->time = arg2;
30776 }
30777
30778
30779 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
30780   unsigned long jresult ;
30781   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30782   unsigned long result;
30783
30784   arg1 = (Dali::HoverEvent *)jarg1;
30785   result = (unsigned long) ((arg1)->time);
30786   jresult = (unsigned long)result;
30787   return jresult;
30788 }
30789
30790
30791 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
30792   unsigned int jresult ;
30793   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30794   unsigned int result;
30795
30796   arg1 = (Dali::HoverEvent *)jarg1;
30797   {
30798     try {
30799       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
30800     } catch (std::out_of_range& e) {
30801       {
30802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30803       };
30804     } catch (std::exception& e) {
30805       {
30806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30807       };
30808     } catch (Dali::DaliException e) {
30809       {
30810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30811       };
30812     } catch (...) {
30813       {
30814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30815       };
30816     }
30817   }
30818
30819   jresult = result;
30820   return jresult;
30821 }
30822
30823
30824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
30825   void * jresult ;
30826   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30827   unsigned int arg2 ;
30828   Dali::TouchPoint *result = 0 ;
30829
30830   arg1 = (Dali::HoverEvent *)jarg1;
30831   arg2 = (unsigned int)jarg2;
30832   {
30833     try {
30834       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
30835     } catch (std::out_of_range& e) {
30836       {
30837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30838       };
30839     } catch (std::exception& e) {
30840       {
30841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30842       };
30843     } catch (Dali::DaliException e) {
30844       {
30845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30846       };
30847     } catch (...) {
30848       {
30849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30850       };
30851     }
30852   }
30853
30854   jresult = (void *)result;
30855   return jresult;
30856 }
30857
30858
30859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
30860   void * jresult ;
30861   Dali::KeyEvent *result = 0 ;
30862
30863   {
30864     try {
30865       result = (Dali::KeyEvent *)new Dali::KeyEvent();
30866     } catch (std::out_of_range& e) {
30867       {
30868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30869       };
30870     } catch (std::exception& e) {
30871       {
30872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30873       };
30874     } catch (Dali::DaliException e) {
30875       {
30876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30877       };
30878     } catch (...) {
30879       {
30880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30881       };
30882     }
30883   }
30884
30885   jresult = (void *)result;
30886   return jresult;
30887 }
30888
30889
30890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
30891   void * jresult ;
30892   std::string *arg1 = 0 ;
30893   std::string *arg2 = 0 ;
30894   int arg3 ;
30895   int arg4 ;
30896   unsigned long arg5 ;
30897   Dali::KeyEvent::State *arg6 = 0 ;
30898   Dali::KeyEvent::State temp6 ;
30899   Dali::KeyEvent *result = 0 ;
30900
30901   if (!jarg1) {
30902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
30903     return 0;
30904   }
30905   std::string arg1_str(jarg1);
30906   arg1 = &arg1_str;
30907   if (!jarg2) {
30908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
30909     return 0;
30910   }
30911   std::string arg2_str(jarg2);
30912   arg2 = &arg2_str;
30913   arg3 = (int)jarg3;
30914   arg4 = (int)jarg4;
30915   arg5 = (unsigned long)jarg5;
30916   temp6 = (Dali::KeyEvent::State)jarg6;
30917   arg6 = &temp6;
30918   {
30919     try {
30920       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
30921     } catch (std::out_of_range& e) {
30922       {
30923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30924       };
30925     } catch (std::exception& e) {
30926       {
30927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30928       };
30929     } catch (Dali::DaliException e) {
30930       {
30931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30932       };
30933     } catch (...) {
30934       {
30935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30936       };
30937     }
30938   }
30939
30940   jresult = (void *)result;
30941
30942   //argout typemap for const std::string&
30943
30944
30945   //argout typemap for const std::string&
30946
30947   return jresult;
30948 }
30949
30950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
30951   void * jresult ;
30952   Dali::KeyEvent *arg1 = 0 ;
30953   Dali::KeyEvent *result = 0 ;
30954
30955   arg1 = (Dali::KeyEvent *)jarg1;
30956   if (!arg1) {
30957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
30958     return 0;
30959   }
30960   {
30961     try {
30962       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
30963     } catch (std::out_of_range& e) {
30964       {
30965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30966       };
30967     } catch (std::exception& e) {
30968       {
30969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30970       };
30971     } catch (Dali::DaliException e) {
30972       {
30973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30974       };
30975     } catch (...) {
30976       {
30977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30978       };
30979     }
30980   }
30981
30982   jresult = (void *)result;
30983   return jresult;
30984 }
30985
30986
30987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
30988   void * jresult ;
30989   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
30990   Dali::KeyEvent *arg2 = 0 ;
30991   Dali::KeyEvent *result = 0 ;
30992
30993   arg1 = (Dali::KeyEvent *)jarg1;
30994   arg2 = (Dali::KeyEvent *)jarg2;
30995   if (!arg2) {
30996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
30997     return 0;
30998   }
30999   {
31000     try {
31001       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
31002     } catch (std::out_of_range& e) {
31003       {
31004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31005       };
31006     } catch (std::exception& e) {
31007       {
31008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31009       };
31010     } catch (Dali::DaliException e) {
31011       {
31012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31013       };
31014     } catch (...) {
31015       {
31016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31017       };
31018     }
31019   }
31020
31021   jresult = (void *)result;
31022   return jresult;
31023 }
31024
31025
31026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
31027   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31028
31029   arg1 = (Dali::KeyEvent *)jarg1;
31030   {
31031     try {
31032       delete arg1;
31033     } catch (std::out_of_range& e) {
31034       {
31035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31036       };
31037     } catch (std::exception& e) {
31038       {
31039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31040       };
31041     } catch (Dali::DaliException e) {
31042       {
31043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31044       };
31045     } catch (...) {
31046       {
31047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31048       };
31049     }
31050   }
31051
31052 }
31053
31054
31055 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
31056   unsigned int jresult ;
31057   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31058   bool result;
31059
31060   arg1 = (Dali::KeyEvent *)jarg1;
31061   {
31062     try {
31063       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
31064     } catch (std::out_of_range& e) {
31065       {
31066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31067       };
31068     } catch (std::exception& e) {
31069       {
31070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31071       };
31072     } catch (Dali::DaliException e) {
31073       {
31074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31075       };
31076     } catch (...) {
31077       {
31078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31079       };
31080     }
31081   }
31082
31083   jresult = result;
31084   return jresult;
31085 }
31086
31087
31088 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
31089   unsigned int jresult ;
31090   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31091   bool result;
31092
31093   arg1 = (Dali::KeyEvent *)jarg1;
31094   {
31095     try {
31096       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
31097     } catch (std::out_of_range& e) {
31098       {
31099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31100       };
31101     } catch (std::exception& e) {
31102       {
31103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31104       };
31105     } catch (Dali::DaliException e) {
31106       {
31107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31108       };
31109     } catch (...) {
31110       {
31111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31112       };
31113     }
31114   }
31115
31116   jresult = result;
31117   return jresult;
31118 }
31119
31120
31121 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
31122   unsigned int jresult ;
31123   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31124   bool result;
31125
31126   arg1 = (Dali::KeyEvent *)jarg1;
31127   {
31128     try {
31129       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
31130     } catch (std::out_of_range& e) {
31131       {
31132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31133       };
31134     } catch (std::exception& e) {
31135       {
31136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31137       };
31138     } catch (Dali::DaliException e) {
31139       {
31140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31141       };
31142     } catch (...) {
31143       {
31144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31145       };
31146     }
31147   }
31148
31149   jresult = result;
31150   return jresult;
31151 }
31152
31153
31154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
31155   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31156   std::string *arg2 = 0 ;
31157
31158   arg1 = (Dali::KeyEvent *)jarg1;
31159   if (!jarg2) {
31160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31161     return ;
31162   }
31163   std::string arg2_str(jarg2);
31164   arg2 = &arg2_str;
31165   if (arg1) (arg1)->keyPressedName = *arg2;
31166
31167   //argout typemap for const std::string&
31168
31169 }
31170
31171
31172 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
31173   char * jresult ;
31174   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31175   std::string *result = 0 ;
31176
31177   arg1 = (Dali::KeyEvent *)jarg1;
31178   result = (std::string *) & ((arg1)->keyPressedName);
31179   jresult = SWIG_csharp_string_callback(result->c_str());
31180   return jresult;
31181 }
31182
31183
31184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
31185   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31186   std::string *arg2 = 0 ;
31187
31188   arg1 = (Dali::KeyEvent *)jarg1;
31189   if (!jarg2) {
31190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31191     return ;
31192   }
31193   std::string arg2_str(jarg2);
31194   arg2 = &arg2_str;
31195   if (arg1) (arg1)->keyPressed = *arg2;
31196
31197   //argout typemap for const std::string&
31198
31199 }
31200
31201
31202 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
31203   char * jresult ;
31204   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31205   std::string *result = 0 ;
31206
31207   arg1 = (Dali::KeyEvent *)jarg1;
31208   result = (std::string *) & ((arg1)->keyPressed);
31209   jresult = SWIG_csharp_string_callback(result->c_str());
31210   return jresult;
31211 }
31212
31213
31214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
31215   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31216   int arg2 ;
31217
31218   arg1 = (Dali::KeyEvent *)jarg1;
31219   arg2 = (int)jarg2;
31220   if (arg1) (arg1)->keyCode = arg2;
31221 }
31222
31223
31224 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
31225   int jresult ;
31226   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31227   int result;
31228
31229   arg1 = (Dali::KeyEvent *)jarg1;
31230   result = (int) ((arg1)->keyCode);
31231   jresult = result;
31232   return jresult;
31233 }
31234
31235
31236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
31237   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31238   int arg2 ;
31239
31240   arg1 = (Dali::KeyEvent *)jarg1;
31241   arg2 = (int)jarg2;
31242   if (arg1) (arg1)->keyModifier = arg2;
31243 }
31244
31245
31246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
31247   int jresult ;
31248   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31249   int result;
31250
31251   arg1 = (Dali::KeyEvent *)jarg1;
31252   result = (int) ((arg1)->keyModifier);
31253   jresult = result;
31254   return jresult;
31255 }
31256
31257
31258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
31259   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31260   unsigned long arg2 ;
31261
31262   arg1 = (Dali::KeyEvent *)jarg1;
31263   arg2 = (unsigned long)jarg2;
31264   if (arg1) (arg1)->time = arg2;
31265 }
31266
31267
31268 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
31269   unsigned long jresult ;
31270   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31271   unsigned long result;
31272
31273   arg1 = (Dali::KeyEvent *)jarg1;
31274   result = (unsigned long) ((arg1)->time);
31275   jresult = (unsigned long)result;
31276   return jresult;
31277 }
31278
31279
31280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
31281   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31282   Dali::KeyEvent::State arg2 ;
31283
31284   arg1 = (Dali::KeyEvent *)jarg1;
31285   arg2 = (Dali::KeyEvent::State)jarg2;
31286   if (arg1) (arg1)->state = arg2;
31287 }
31288
31289
31290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
31291   int jresult ;
31292   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31293   Dali::KeyEvent::State result;
31294
31295   arg1 = (Dali::KeyEvent *)jarg1;
31296   result = (Dali::KeyEvent::State) ((arg1)->state);
31297   jresult = (int)result;
31298   return jresult;
31299 }
31300
31301
31302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
31303   void * jresult ;
31304   Dali::LongPressGestureDetector *result = 0 ;
31305
31306   {
31307     try {
31308       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
31309     } catch (std::out_of_range& e) {
31310       {
31311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31312       };
31313     } catch (std::exception& e) {
31314       {
31315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31316       };
31317     } catch (Dali::DaliException e) {
31318       {
31319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31320       };
31321     } catch (...) {
31322       {
31323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31324       };
31325     }
31326   }
31327
31328   jresult = (void *)result;
31329   return jresult;
31330 }
31331
31332
31333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
31334   void * jresult ;
31335   Dali::LongPressGestureDetector result;
31336
31337   {
31338     try {
31339       result = Dali::LongPressGestureDetector::New();
31340     } catch (std::out_of_range& e) {
31341       {
31342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31343       };
31344     } catch (std::exception& e) {
31345       {
31346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31347       };
31348     } catch (Dali::DaliException e) {
31349       {
31350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31351       };
31352     } catch (...) {
31353       {
31354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31355       };
31356     }
31357   }
31358
31359   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31360   return jresult;
31361 }
31362
31363
31364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
31365   void * jresult ;
31366   unsigned int arg1 ;
31367   Dali::LongPressGestureDetector result;
31368
31369   arg1 = (unsigned int)jarg1;
31370   {
31371     try {
31372       result = Dali::LongPressGestureDetector::New(arg1);
31373     } catch (std::out_of_range& e) {
31374       {
31375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31376       };
31377     } catch (std::exception& e) {
31378       {
31379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31380       };
31381     } catch (Dali::DaliException e) {
31382       {
31383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31384       };
31385     } catch (...) {
31386       {
31387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31388       };
31389     }
31390   }
31391
31392   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31393   return jresult;
31394 }
31395
31396
31397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
31398   void * jresult ;
31399   unsigned int arg1 ;
31400   unsigned int arg2 ;
31401   Dali::LongPressGestureDetector result;
31402
31403   arg1 = (unsigned int)jarg1;
31404   arg2 = (unsigned int)jarg2;
31405   {
31406     try {
31407       result = Dali::LongPressGestureDetector::New(arg1,arg2);
31408     } catch (std::out_of_range& e) {
31409       {
31410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31411       };
31412     } catch (std::exception& e) {
31413       {
31414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31415       };
31416     } catch (Dali::DaliException e) {
31417       {
31418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31419       };
31420     } catch (...) {
31421       {
31422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31423       };
31424     }
31425   }
31426
31427   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31428   return jresult;
31429 }
31430
31431
31432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
31433   void * jresult ;
31434   Dali::BaseHandle arg1 ;
31435   Dali::BaseHandle *argp1 ;
31436   Dali::LongPressGestureDetector result;
31437
31438   argp1 = (Dali::BaseHandle *)jarg1;
31439   if (!argp1) {
31440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31441     return 0;
31442   }
31443   arg1 = *argp1;
31444   {
31445     try {
31446       result = Dali::LongPressGestureDetector::DownCast(arg1);
31447     } catch (std::out_of_range& e) {
31448       {
31449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31450       };
31451     } catch (std::exception& e) {
31452       {
31453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31454       };
31455     } catch (Dali::DaliException e) {
31456       {
31457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31458       };
31459     } catch (...) {
31460       {
31461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31462       };
31463     }
31464   }
31465
31466   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31467   return jresult;
31468 }
31469
31470
31471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
31472   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31473
31474   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31475   {
31476     try {
31477       delete arg1;
31478     } catch (std::out_of_range& e) {
31479       {
31480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31481       };
31482     } catch (std::exception& e) {
31483       {
31484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31485       };
31486     } catch (Dali::DaliException e) {
31487       {
31488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31489       };
31490     } catch (...) {
31491       {
31492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31493       };
31494     }
31495   }
31496
31497 }
31498
31499
31500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
31501   void * jresult ;
31502   Dali::LongPressGestureDetector *arg1 = 0 ;
31503   Dali::LongPressGestureDetector *result = 0 ;
31504
31505   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31506   if (!arg1) {
31507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31508     return 0;
31509   }
31510   {
31511     try {
31512       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
31513     } catch (std::out_of_range& e) {
31514       {
31515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31516       };
31517     } catch (std::exception& e) {
31518       {
31519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31520       };
31521     } catch (Dali::DaliException e) {
31522       {
31523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31524       };
31525     } catch (...) {
31526       {
31527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31528       };
31529     }
31530   }
31531
31532   jresult = (void *)result;
31533   return jresult;
31534 }
31535
31536
31537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
31538   void * jresult ;
31539   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31540   Dali::LongPressGestureDetector *arg2 = 0 ;
31541   Dali::LongPressGestureDetector *result = 0 ;
31542
31543   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31544   arg2 = (Dali::LongPressGestureDetector *)jarg2;
31545   if (!arg2) {
31546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31547     return 0;
31548   }
31549   {
31550     try {
31551       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
31552     } catch (std::out_of_range& e) {
31553       {
31554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31555       };
31556     } catch (std::exception& e) {
31557       {
31558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31559       };
31560     } catch (Dali::DaliException e) {
31561       {
31562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31563       };
31564     } catch (...) {
31565       {
31566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31567       };
31568     }
31569   }
31570
31571   jresult = (void *)result;
31572   return jresult;
31573 }
31574
31575
31576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
31577   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31578   unsigned int arg2 ;
31579
31580   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31581   arg2 = (unsigned int)jarg2;
31582   {
31583     try {
31584       (arg1)->SetTouchesRequired(arg2);
31585     } catch (std::out_of_range& e) {
31586       {
31587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31588       };
31589     } catch (std::exception& e) {
31590       {
31591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31592       };
31593     } catch (Dali::DaliException e) {
31594       {
31595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31596       };
31597     } catch (...) {
31598       {
31599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31600       };
31601     }
31602   }
31603
31604 }
31605
31606
31607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
31608   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31609   unsigned int arg2 ;
31610   unsigned int arg3 ;
31611
31612   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31613   arg2 = (unsigned int)jarg2;
31614   arg3 = (unsigned int)jarg3;
31615   {
31616     try {
31617       (arg1)->SetTouchesRequired(arg2,arg3);
31618     } catch (std::out_of_range& e) {
31619       {
31620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31621       };
31622     } catch (std::exception& e) {
31623       {
31624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31625       };
31626     } catch (Dali::DaliException e) {
31627       {
31628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31629       };
31630     } catch (...) {
31631       {
31632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31633       };
31634     }
31635   }
31636
31637 }
31638
31639
31640 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
31641   unsigned int jresult ;
31642   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31643   unsigned int result;
31644
31645   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31646   {
31647     try {
31648       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
31649     } catch (std::out_of_range& e) {
31650       {
31651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31652       };
31653     } catch (std::exception& e) {
31654       {
31655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31656       };
31657     } catch (Dali::DaliException e) {
31658       {
31659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31660       };
31661     } catch (...) {
31662       {
31663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31664       };
31665     }
31666   }
31667
31668   jresult = result;
31669   return jresult;
31670 }
31671
31672
31673 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
31674   unsigned int jresult ;
31675   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31676   unsigned int result;
31677
31678   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31679   {
31680     try {
31681       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
31682     } catch (std::out_of_range& e) {
31683       {
31684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31685       };
31686     } catch (std::exception& e) {
31687       {
31688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31689       };
31690     } catch (Dali::DaliException e) {
31691       {
31692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31693       };
31694     } catch (...) {
31695       {
31696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31697       };
31698     }
31699   }
31700
31701   jresult = result;
31702   return jresult;
31703 }
31704
31705
31706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
31707   void * jresult ;
31708   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31709   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
31710
31711   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31712   {
31713     try {
31714       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
31715     } catch (std::out_of_range& e) {
31716       {
31717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31718       };
31719     } catch (std::exception& e) {
31720       {
31721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31722       };
31723     } catch (Dali::DaliException e) {
31724       {
31725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31726       };
31727     } catch (...) {
31728       {
31729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31730       };
31731     }
31732   }
31733
31734   jresult = (void *)result;
31735   return jresult;
31736 }
31737
31738
31739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
31740   void * jresult ;
31741   Dali::Gesture::State arg1 ;
31742   Dali::LongPressGesture *result = 0 ;
31743
31744   arg1 = (Dali::Gesture::State)jarg1;
31745   {
31746     try {
31747       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
31748     } catch (std::out_of_range& e) {
31749       {
31750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31751       };
31752     } catch (std::exception& e) {
31753       {
31754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31755       };
31756     } catch (Dali::DaliException e) {
31757       {
31758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31759       };
31760     } catch (...) {
31761       {
31762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31763       };
31764     }
31765   }
31766
31767   jresult = (void *)result;
31768   return jresult;
31769 }
31770
31771
31772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
31773   void * jresult ;
31774   Dali::LongPressGesture *arg1 = 0 ;
31775   Dali::LongPressGesture *result = 0 ;
31776
31777   arg1 = (Dali::LongPressGesture *)jarg1;
31778   if (!arg1) {
31779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31780     return 0;
31781   }
31782   {
31783     try {
31784       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
31785     } catch (std::out_of_range& e) {
31786       {
31787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31788       };
31789     } catch (std::exception& e) {
31790       {
31791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31792       };
31793     } catch (Dali::DaliException e) {
31794       {
31795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31796       };
31797     } catch (...) {
31798       {
31799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31800       };
31801     }
31802   }
31803
31804   jresult = (void *)result;
31805   return jresult;
31806 }
31807
31808
31809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
31810   void * jresult ;
31811   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31812   Dali::LongPressGesture *arg2 = 0 ;
31813   Dali::LongPressGesture *result = 0 ;
31814
31815   arg1 = (Dali::LongPressGesture *)jarg1;
31816   arg2 = (Dali::LongPressGesture *)jarg2;
31817   if (!arg2) {
31818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31819     return 0;
31820   }
31821   {
31822     try {
31823       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
31824     } catch (std::out_of_range& e) {
31825       {
31826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31827       };
31828     } catch (std::exception& e) {
31829       {
31830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31831       };
31832     } catch (Dali::DaliException e) {
31833       {
31834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31835       };
31836     } catch (...) {
31837       {
31838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31839       };
31840     }
31841   }
31842
31843   jresult = (void *)result;
31844   return jresult;
31845 }
31846
31847
31848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
31849   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31850
31851   arg1 = (Dali::LongPressGesture *)jarg1;
31852   {
31853     try {
31854       delete arg1;
31855     } catch (std::out_of_range& e) {
31856       {
31857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31858       };
31859     } catch (std::exception& e) {
31860       {
31861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31862       };
31863     } catch (Dali::DaliException e) {
31864       {
31865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31866       };
31867     } catch (...) {
31868       {
31869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31870       };
31871     }
31872   }
31873
31874 }
31875
31876
31877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
31878   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31879   unsigned int arg2 ;
31880
31881   arg1 = (Dali::LongPressGesture *)jarg1;
31882   arg2 = (unsigned int)jarg2;
31883   if (arg1) (arg1)->numberOfTouches = arg2;
31884 }
31885
31886
31887 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
31888   unsigned int jresult ;
31889   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31890   unsigned int result;
31891
31892   arg1 = (Dali::LongPressGesture *)jarg1;
31893   result = (unsigned int) ((arg1)->numberOfTouches);
31894   jresult = result;
31895   return jresult;
31896 }
31897
31898
31899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
31900   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31901   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
31902
31903   arg1 = (Dali::LongPressGesture *)jarg1;
31904   arg2 = (Dali::Vector2 *)jarg2;
31905   if (arg1) (arg1)->screenPoint = *arg2;
31906 }
31907
31908
31909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
31910   void * jresult ;
31911   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31912   Dali::Vector2 *result = 0 ;
31913
31914   arg1 = (Dali::LongPressGesture *)jarg1;
31915   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
31916   jresult = (void *)result;
31917   return jresult;
31918 }
31919
31920
31921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
31922   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31923   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
31924
31925   arg1 = (Dali::LongPressGesture *)jarg1;
31926   arg2 = (Dali::Vector2 *)jarg2;
31927   if (arg1) (arg1)->localPoint = *arg2;
31928 }
31929
31930
31931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
31932   void * jresult ;
31933   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31934   Dali::Vector2 *result = 0 ;
31935
31936   arg1 = (Dali::LongPressGesture *)jarg1;
31937   result = (Dali::Vector2 *)& ((arg1)->localPoint);
31938   jresult = (void *)result;
31939   return jresult;
31940 }
31941
31942
31943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
31944   void * jresult ;
31945   Dali::WheelEvent *result = 0 ;
31946
31947   {
31948     try {
31949       result = (Dali::WheelEvent *)new Dali::WheelEvent();
31950     } catch (std::out_of_range& e) {
31951       {
31952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31953       };
31954     } catch (std::exception& e) {
31955       {
31956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31957       };
31958     } catch (Dali::DaliException e) {
31959       {
31960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31961       };
31962     } catch (...) {
31963       {
31964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31965       };
31966     }
31967   }
31968
31969   jresult = (void *)result;
31970   return jresult;
31971 }
31972
31973
31974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
31975   void * jresult ;
31976   Dali::WheelEvent::Type arg1 ;
31977   int arg2 ;
31978   unsigned int arg3 ;
31979   Dali::Vector2 arg4 ;
31980   int arg5 ;
31981   unsigned int arg6 ;
31982   Dali::Vector2 *argp4 ;
31983   Dali::WheelEvent *result = 0 ;
31984
31985   arg1 = (Dali::WheelEvent::Type)jarg1;
31986   arg2 = (int)jarg2;
31987   arg3 = (unsigned int)jarg3;
31988   argp4 = (Dali::Vector2 *)jarg4;
31989   if (!argp4) {
31990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
31991     return 0;
31992   }
31993   arg4 = *argp4;
31994   arg5 = (int)jarg5;
31995   arg6 = (unsigned int)jarg6;
31996   {
31997     try {
31998       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
31999     } catch (std::out_of_range& e) {
32000       {
32001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32002       };
32003     } catch (std::exception& e) {
32004       {
32005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32006       };
32007     } catch (Dali::DaliException e) {
32008       {
32009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32010       };
32011     } catch (...) {
32012       {
32013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32014       };
32015     }
32016   }
32017
32018   jresult = (void *)result;
32019   return jresult;
32020 }
32021
32022
32023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
32024   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32025
32026   arg1 = (Dali::WheelEvent *)jarg1;
32027   {
32028     try {
32029       delete arg1;
32030     } catch (std::out_of_range& e) {
32031       {
32032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32033       };
32034     } catch (std::exception& e) {
32035       {
32036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32037       };
32038     } catch (Dali::DaliException e) {
32039       {
32040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32041       };
32042     } catch (...) {
32043       {
32044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32045       };
32046     }
32047   }
32048
32049 }
32050
32051
32052 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
32053   unsigned int jresult ;
32054   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32055   bool result;
32056
32057   arg1 = (Dali::WheelEvent *)jarg1;
32058   {
32059     try {
32060       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
32061     } catch (std::out_of_range& e) {
32062       {
32063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32064       };
32065     } catch (std::exception& e) {
32066       {
32067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32068       };
32069     } catch (Dali::DaliException e) {
32070       {
32071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32072       };
32073     } catch (...) {
32074       {
32075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32076       };
32077     }
32078   }
32079
32080   jresult = result;
32081   return jresult;
32082 }
32083
32084
32085 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
32086   unsigned int jresult ;
32087   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32088   bool result;
32089
32090   arg1 = (Dali::WheelEvent *)jarg1;
32091   {
32092     try {
32093       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
32094     } catch (std::out_of_range& e) {
32095       {
32096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32097       };
32098     } catch (std::exception& e) {
32099       {
32100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32101       };
32102     } catch (Dali::DaliException e) {
32103       {
32104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32105       };
32106     } catch (...) {
32107       {
32108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32109       };
32110     }
32111   }
32112
32113   jresult = result;
32114   return jresult;
32115 }
32116
32117
32118 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
32119   unsigned int jresult ;
32120   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32121   bool result;
32122
32123   arg1 = (Dali::WheelEvent *)jarg1;
32124   {
32125     try {
32126       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
32127     } catch (std::out_of_range& e) {
32128       {
32129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32130       };
32131     } catch (std::exception& e) {
32132       {
32133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32134       };
32135     } catch (Dali::DaliException e) {
32136       {
32137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32138       };
32139     } catch (...) {
32140       {
32141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32142       };
32143     }
32144   }
32145
32146   jresult = result;
32147   return jresult;
32148 }
32149
32150
32151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
32152   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32153   Dali::WheelEvent::Type arg2 ;
32154
32155   arg1 = (Dali::WheelEvent *)jarg1;
32156   arg2 = (Dali::WheelEvent::Type)jarg2;
32157   if (arg1) (arg1)->type = arg2;
32158 }
32159
32160
32161 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
32162   int jresult ;
32163   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32164   Dali::WheelEvent::Type result;
32165
32166   arg1 = (Dali::WheelEvent *)jarg1;
32167   result = (Dali::WheelEvent::Type) ((arg1)->type);
32168   jresult = (int)result;
32169   return jresult;
32170 }
32171
32172
32173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
32174   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32175   int arg2 ;
32176
32177   arg1 = (Dali::WheelEvent *)jarg1;
32178   arg2 = (int)jarg2;
32179   if (arg1) (arg1)->direction = arg2;
32180 }
32181
32182
32183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
32184   int jresult ;
32185   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32186   int result;
32187
32188   arg1 = (Dali::WheelEvent *)jarg1;
32189   result = (int) ((arg1)->direction);
32190   jresult = result;
32191   return jresult;
32192 }
32193
32194
32195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
32196   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32197   unsigned int arg2 ;
32198
32199   arg1 = (Dali::WheelEvent *)jarg1;
32200   arg2 = (unsigned int)jarg2;
32201   if (arg1) (arg1)->modifiers = arg2;
32202 }
32203
32204
32205 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
32206   unsigned int jresult ;
32207   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32208   unsigned int result;
32209
32210   arg1 = (Dali::WheelEvent *)jarg1;
32211   result = (unsigned int) ((arg1)->modifiers);
32212   jresult = result;
32213   return jresult;
32214 }
32215
32216
32217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
32218   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32219   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32220
32221   arg1 = (Dali::WheelEvent *)jarg1;
32222   arg2 = (Dali::Vector2 *)jarg2;
32223   if (arg1) (arg1)->point = *arg2;
32224 }
32225
32226
32227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
32228   void * jresult ;
32229   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32230   Dali::Vector2 *result = 0 ;
32231
32232   arg1 = (Dali::WheelEvent *)jarg1;
32233   result = (Dali::Vector2 *)& ((arg1)->point);
32234   jresult = (void *)result;
32235   return jresult;
32236 }
32237
32238
32239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
32240   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32241   int arg2 ;
32242
32243   arg1 = (Dali::WheelEvent *)jarg1;
32244   arg2 = (int)jarg2;
32245   if (arg1) (arg1)->z = arg2;
32246 }
32247
32248
32249 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
32250   int jresult ;
32251   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32252   int result;
32253
32254   arg1 = (Dali::WheelEvent *)jarg1;
32255   result = (int) ((arg1)->z);
32256   jresult = result;
32257   return jresult;
32258 }
32259
32260
32261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
32262   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32263   unsigned int arg2 ;
32264
32265   arg1 = (Dali::WheelEvent *)jarg1;
32266   arg2 = (unsigned int)jarg2;
32267   if (arg1) (arg1)->timeStamp = arg2;
32268 }
32269
32270
32271 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
32272   unsigned int jresult ;
32273   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32274   unsigned int result;
32275
32276   arg1 = (Dali::WheelEvent *)jarg1;
32277   result = (unsigned int) ((arg1)->timeStamp);
32278   jresult = result;
32279   return jresult;
32280 }
32281
32282 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
32283   char * jresult ;
32284   Dali::KeyEvent *arg1 = 0 ;
32285   std::string result;
32286
32287   arg1 = (Dali::KeyEvent *)jarg1;
32288   if (!arg1) {
32289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32290     return 0;
32291   }
32292   {
32293     try {
32294       result = arg1->GetDeviceName();
32295     } catch (std::out_of_range& e) {
32296       {
32297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32298       };
32299     } catch (std::exception& e) {
32300       {
32301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32302       };
32303     } catch (Dali::DaliException e) {
32304       {
32305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32306       };
32307     } catch (...) {
32308       {
32309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32310       };
32311     }
32312   }
32313
32314   jresult = SWIG_csharp_string_callback((&result)->c_str());
32315   return jresult;
32316 }
32317
32318 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
32319   int jresult ;
32320   Dali::KeyEvent *arg1 = 0 ;
32321   Dali::Device::Class::Type result;
32322
32323   arg1 = (Dali::KeyEvent *)jarg1;
32324   if (!arg1) {
32325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32326     return 0;
32327   }
32328   {
32329     try {
32330       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
32331     } catch (std::out_of_range& e) {
32332       {
32333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32334       };
32335     } catch (std::exception& e) {
32336       {
32337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32338       };
32339     } catch (Dali::DaliException e) {
32340       {
32341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32342       };
32343     } catch (...) {
32344       {
32345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32346       };
32347     }
32348   }
32349
32350   jresult = (int)result;
32351   return jresult;
32352 }
32353
32354 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
32355   int jresult ;
32356   Dali::KeyEvent *arg1 = 0 ;
32357   Dali::Device::Subclass::Type result;
32358
32359   arg1 = (Dali::KeyEvent *)jarg1;
32360   if (!arg1) {
32361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32362     return 0;
32363   }
32364   {
32365     try {
32366       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
32367     } catch (std::out_of_range& e) {
32368       {
32369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32370       };
32371     } catch (std::exception& e) {
32372       {
32373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32374       };
32375     } catch (Dali::DaliException e) {
32376       {
32377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32378       };
32379     } catch (...) {
32380       {
32381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32382       };
32383     }
32384   }
32385
32386   jresult = (int)result;
32387   return jresult;
32388 }
32389
32390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32391   Dali::Actor arg1 ;
32392   Dali::Actor *argp1 ;
32393
32394   argp1 = (Dali::Actor *)jarg1;
32395   if (!argp1) {
32396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32397     return ;
32398   }
32399   arg1 = *argp1;
32400   {
32401     try {
32402       arg1.Raise();
32403     } catch (std::out_of_range& e) {
32404       {
32405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32406       };
32407     } catch (std::exception& e) {
32408       {
32409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32410       };
32411     } catch (Dali::DaliException e) {
32412       {
32413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32414       };
32415     } catch (...) {
32416       {
32417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32418       };
32419     }
32420   }
32421
32422 }
32423
32424
32425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32426   Dali::Actor arg1 ;
32427   Dali::Actor *argp1 ;
32428
32429   argp1 = (Dali::Actor *)jarg1;
32430   if (!argp1) {
32431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32432     return ;
32433   }
32434   arg1 = *argp1;
32435   {
32436     try {
32437       arg1.Lower();
32438     } catch (std::out_of_range& e) {
32439       {
32440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32441       };
32442     } catch (std::exception& e) {
32443       {
32444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32445       };
32446     } catch (Dali::DaliException e) {
32447       {
32448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32449       };
32450     } catch (...) {
32451       {
32452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32453       };
32454     }
32455   }
32456
32457 }
32458
32459
32460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32461   Dali::Actor arg1 ;
32462   Dali::Actor *argp1 ;
32463
32464   argp1 = (Dali::Actor *)jarg1;
32465   if (!argp1) {
32466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32467     return ;
32468   }
32469   arg1 = *argp1;
32470   {
32471     try {
32472       arg1.RaiseToTop();
32473     } catch (std::out_of_range& e) {
32474       {
32475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32476       };
32477     } catch (std::exception& e) {
32478       {
32479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32480       };
32481     } catch (Dali::DaliException e) {
32482       {
32483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32484       };
32485     } catch (...) {
32486       {
32487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32488       };
32489     }
32490   }
32491
32492 }
32493
32494
32495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32496   Dali::Actor arg1 ;
32497   Dali::Actor *argp1 ;
32498
32499   argp1 = (Dali::Actor *)jarg1;
32500   if (!argp1) {
32501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32502     return ;
32503   }
32504   arg1 = *argp1;
32505   {
32506     try {
32507       arg1.LowerToBottom();
32508     } catch (std::out_of_range& e) {
32509       {
32510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32511       };
32512     } catch (std::exception& e) {
32513       {
32514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32515       };
32516     } catch (Dali::DaliException e) {
32517       {
32518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32519       };
32520     } catch (...) {
32521       {
32522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32523       };
32524     }
32525   }
32526
32527 }
32528
32529
32530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32531   Dali::Actor arg1 ;
32532   Dali::Actor arg2 ;
32533   Dali::Actor *argp1 ;
32534   Dali::Actor *argp2 ;
32535
32536   argp1 = (Dali::Actor *)jarg1;
32537   if (!argp1) {
32538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32539     return ;
32540   }
32541   arg1 = *argp1;
32542   argp2 = (Dali::Actor *)jarg2;
32543   if (!argp2) {
32544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32545     return ;
32546   }
32547   arg2 = *argp2;
32548   {
32549     try {
32550       arg1.RaiseAbove(arg2);
32551     } catch (std::out_of_range& e) {
32552       {
32553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32554       };
32555     } catch (std::exception& e) {
32556       {
32557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32558       };
32559     } catch (Dali::DaliException e) {
32560       {
32561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32562       };
32563     } catch (...) {
32564       {
32565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32566       };
32567     }
32568   }
32569
32570 }
32571
32572
32573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32574   Dali::Actor arg1 ;
32575   Dali::Actor arg2 ;
32576   Dali::Actor *argp1 ;
32577   Dali::Actor *argp2 ;
32578
32579   argp1 = (Dali::Actor *)jarg1;
32580   if (!argp1) {
32581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32582     return ;
32583   }
32584   arg1 = *argp1;
32585   argp2 = (Dali::Actor *)jarg2;
32586   if (!argp2) {
32587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32588     return ;
32589   }
32590   arg2 = *argp2;
32591   {
32592     try {
32593       arg1.LowerBelow(arg2);
32594     } catch (std::out_of_range& e) {
32595       {
32596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32597       };
32598     } catch (std::exception& e) {
32599       {
32600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32601       };
32602     } catch (Dali::DaliException e) {
32603       {
32604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32605       };
32606     } catch (...) {
32607       {
32608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32609       };
32610     }
32611   }
32612
32613 }
32614
32615
32616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
32617   void * jresult ;
32618   Dali::Actor arg1 ;
32619   Dali::Actor *argp1 ;
32620   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
32621
32622   argp1 = (Dali::Actor *)jarg1;
32623   if (!argp1) {
32624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32625     return 0;
32626   }
32627   arg1 = *argp1;
32628   {
32629     try {
32630       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
32631     } catch (std::out_of_range& e) {
32632       {
32633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32634       };
32635     } catch (std::exception& e) {
32636       {
32637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32638       };
32639     } catch (Dali::DaliException e) {
32640       {
32641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32642       };
32643     } catch (...) {
32644       {
32645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32646       };
32647     }
32648   }
32649
32650   jresult = (void *)result;
32651   return jresult;
32652 }
32653
32654
32655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
32656   void * jresult ;
32657   Dali::Actor *arg1 ;
32658   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
32659
32660   arg1 = (Dali::Actor *)jarg1;
32661   {
32662     try {
32663       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
32664     } catch (std::out_of_range& e) {
32665       {
32666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32667       };
32668     } catch (std::exception& e) {
32669       {
32670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32671       };
32672     } catch (Dali::DaliException e) {
32673       {
32674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32675       };
32676     } catch (...) {
32677       {
32678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32679       };
32680     }
32681   }
32682
32683   jresult = (void *)result;
32684   return jresult;
32685 }
32686
32687
32688 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
32689   int jresult ;
32690   int result;
32691
32692   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
32693   jresult = (int)result;
32694   return jresult;
32695 }
32696
32697
32698 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
32699   int jresult ;
32700   int result;
32701
32702   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
32703   jresult = (int)result;
32704   return jresult;
32705 }
32706
32707
32708 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
32709   int jresult ;
32710   int result;
32711
32712   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
32713   jresult = (int)result;
32714   return jresult;
32715 }
32716
32717
32718 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
32719   int jresult ;
32720   int result;
32721
32722   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
32723   jresult = (int)result;
32724   return jresult;
32725 }
32726
32727
32728 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
32729   int jresult ;
32730   int result;
32731
32732   result = (int)Dali::Actor::Property::ANCHOR_POINT;
32733   jresult = (int)result;
32734   return jresult;
32735 }
32736
32737
32738 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
32739   int jresult ;
32740   int result;
32741
32742   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
32743   jresult = (int)result;
32744   return jresult;
32745 }
32746
32747
32748 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
32749   int jresult ;
32750   int result;
32751
32752   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
32753   jresult = (int)result;
32754   return jresult;
32755 }
32756
32757
32758 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
32759   int jresult ;
32760   int result;
32761
32762   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
32763   jresult = (int)result;
32764   return jresult;
32765 }
32766
32767
32768 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
32769   int jresult ;
32770   int result;
32771
32772   result = (int)Dali::Actor::Property::SIZE;
32773   jresult = (int)result;
32774   return jresult;
32775 }
32776
32777
32778 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
32779   int jresult ;
32780   int result;
32781
32782   result = (int)Dali::Actor::Property::SIZE_WIDTH;
32783   jresult = (int)result;
32784   return jresult;
32785 }
32786
32787
32788 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
32789   int jresult ;
32790   int result;
32791
32792   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
32793   jresult = (int)result;
32794   return jresult;
32795 }
32796
32797
32798 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
32799   int jresult ;
32800   int result;
32801
32802   result = (int)Dali::Actor::Property::SIZE_DEPTH;
32803   jresult = (int)result;
32804   return jresult;
32805 }
32806
32807
32808 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
32809   int jresult ;
32810   int result;
32811
32812   result = (int)Dali::Actor::Property::POSITION;
32813   jresult = (int)result;
32814   return jresult;
32815 }
32816
32817
32818 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
32819   int jresult ;
32820   int result;
32821
32822   result = (int)Dali::Actor::Property::POSITION_X;
32823   jresult = (int)result;
32824   return jresult;
32825 }
32826
32827
32828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
32829   int jresult ;
32830   int result;
32831
32832   result = (int)Dali::Actor::Property::POSITION_Y;
32833   jresult = (int)result;
32834   return jresult;
32835 }
32836
32837
32838 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
32839   int jresult ;
32840   int result;
32841
32842   result = (int)Dali::Actor::Property::POSITION_Z;
32843   jresult = (int)result;
32844   return jresult;
32845 }
32846
32847
32848 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
32849   int jresult ;
32850   int result;
32851
32852   result = (int)Dali::Actor::Property::WORLD_POSITION;
32853   jresult = (int)result;
32854   return jresult;
32855 }
32856
32857
32858 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
32859   int jresult ;
32860   int result;
32861
32862   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
32863   jresult = (int)result;
32864   return jresult;
32865 }
32866
32867
32868 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
32869   int jresult ;
32870   int result;
32871
32872   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
32873   jresult = (int)result;
32874   return jresult;
32875 }
32876
32877
32878 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
32879   int jresult ;
32880   int result;
32881
32882   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
32883   jresult = (int)result;
32884   return jresult;
32885 }
32886
32887
32888 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
32889   int jresult ;
32890   int result;
32891
32892   result = (int)Dali::Actor::Property::ORIENTATION;
32893   jresult = (int)result;
32894   return jresult;
32895 }
32896
32897
32898 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
32899   int jresult ;
32900   int result;
32901
32902   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
32903   jresult = (int)result;
32904   return jresult;
32905 }
32906
32907
32908 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
32909   int jresult ;
32910   int result;
32911
32912   result = (int)Dali::Actor::Property::SCALE;
32913   jresult = (int)result;
32914   return jresult;
32915 }
32916
32917
32918 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
32919   int jresult ;
32920   int result;
32921
32922   result = (int)Dali::Actor::Property::SCALE_X;
32923   jresult = (int)result;
32924   return jresult;
32925 }
32926
32927
32928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
32929   int jresult ;
32930   int result;
32931
32932   result = (int)Dali::Actor::Property::SCALE_Y;
32933   jresult = (int)result;
32934   return jresult;
32935 }
32936
32937
32938 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
32939   int jresult ;
32940   int result;
32941
32942   result = (int)Dali::Actor::Property::SCALE_Z;
32943   jresult = (int)result;
32944   return jresult;
32945 }
32946
32947
32948 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
32949   int jresult ;
32950   int result;
32951
32952   result = (int)Dali::Actor::Property::WORLD_SCALE;
32953   jresult = (int)result;
32954   return jresult;
32955 }
32956
32957
32958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
32959   int jresult ;
32960   int result;
32961
32962   result = (int)Dali::Actor::Property::VISIBLE;
32963   jresult = (int)result;
32964   return jresult;
32965 }
32966
32967
32968 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
32969   int jresult ;
32970   int result;
32971
32972   result = (int)Dali::Actor::Property::COLOR;
32973   jresult = (int)result;
32974   return jresult;
32975 }
32976
32977
32978 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
32979   int jresult ;
32980   int result;
32981
32982   result = (int)Dali::Actor::Property::COLOR_RED;
32983   jresult = (int)result;
32984   return jresult;
32985 }
32986
32987
32988 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
32989   int jresult ;
32990   int result;
32991
32992   result = (int)Dali::Actor::Property::COLOR_GREEN;
32993   jresult = (int)result;
32994   return jresult;
32995 }
32996
32997
32998 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
32999   int jresult ;
33000   int result;
33001
33002   result = (int)Dali::Actor::Property::COLOR_BLUE;
33003   jresult = (int)result;
33004   return jresult;
33005 }
33006
33007
33008 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
33009   int jresult ;
33010   int result;
33011
33012   result = (int)Dali::Actor::Property::COLOR_ALPHA;
33013   jresult = (int)result;
33014   return jresult;
33015 }
33016
33017
33018 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
33019   int jresult ;
33020   int result;
33021
33022   result = (int)Dali::Actor::Property::WORLD_COLOR;
33023   jresult = (int)result;
33024   return jresult;
33025 }
33026
33027
33028 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
33029   int jresult ;
33030   int result;
33031
33032   result = (int)Dali::Actor::Property::WORLD_MATRIX;
33033   jresult = (int)result;
33034   return jresult;
33035 }
33036
33037
33038 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
33039   int jresult ;
33040   int result;
33041
33042   result = (int)Dali::Actor::Property::NAME;
33043   jresult = (int)result;
33044   return jresult;
33045 }
33046
33047
33048 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
33049   int jresult ;
33050   int result;
33051
33052   result = (int)Dali::Actor::Property::SENSITIVE;
33053   jresult = (int)result;
33054   return jresult;
33055 }
33056
33057
33058 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
33059   int jresult ;
33060   int result;
33061
33062   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
33063   jresult = (int)result;
33064   return jresult;
33065 }
33066
33067
33068 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
33069   int jresult ;
33070   int result;
33071
33072   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
33073   jresult = (int)result;
33074   return jresult;
33075 }
33076
33077
33078 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
33079   int jresult ;
33080   int result;
33081
33082   result = (int)Dali::Actor::Property::INHERIT_SCALE;
33083   jresult = (int)result;
33084   return jresult;
33085 }
33086
33087
33088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
33089   int jresult ;
33090   int result;
33091
33092   result = (int)Dali::Actor::Property::COLOR_MODE;
33093   jresult = (int)result;
33094   return jresult;
33095 }
33096
33097
33098 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_INHERITANCE_get() {
33099   int jresult ;
33100   int result;
33101
33102   result = (int)Dali::Actor::Property::POSITION_INHERITANCE;
33103   jresult = (int)result;
33104   return jresult;
33105 }
33106
33107
33108 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
33109   int jresult ;
33110   int result;
33111
33112   result = (int)Dali::Actor::Property::DRAW_MODE;
33113   jresult = (int)result;
33114   return jresult;
33115 }
33116
33117
33118 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
33119   int jresult ;
33120   int result;
33121
33122   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
33123   jresult = (int)result;
33124   return jresult;
33125 }
33126
33127
33128 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
33129   int jresult ;
33130   int result;
33131
33132   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
33133   jresult = (int)result;
33134   return jresult;
33135 }
33136
33137
33138 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
33139   int jresult ;
33140   int result;
33141
33142   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
33143   jresult = (int)result;
33144   return jresult;
33145 }
33146
33147
33148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
33149   int jresult ;
33150   int result;
33151
33152   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
33153   jresult = (int)result;
33154   return jresult;
33155 }
33156
33157
33158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
33159   int jresult ;
33160   int result;
33161
33162   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
33163   jresult = (int)result;
33164   return jresult;
33165 }
33166
33167
33168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
33169   int jresult ;
33170   int result;
33171
33172   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
33173   jresult = (int)result;
33174   return jresult;
33175 }
33176
33177
33178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
33179   int jresult ;
33180   int result;
33181
33182   result = (int)Dali::Actor::Property::PADDING;
33183   jresult = (int)result;
33184   return jresult;
33185 }
33186
33187
33188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
33189   int jresult ;
33190   int result;
33191
33192   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
33193   jresult = (int)result;
33194   return jresult;
33195 }
33196
33197
33198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
33199   int jresult ;
33200   int result;
33201
33202   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
33203   jresult = (int)result;
33204   return jresult;
33205 }
33206
33207
33208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
33209   int jresult ;
33210   int result;
33211
33212   result = (int)Dali::Actor::Property::INHERIT_POSITION;
33213   jresult = (int)result;
33214   return jresult;
33215 }
33216
33217
33218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
33219   int jresult ;
33220   int result;
33221
33222   result = (int)Dali::Actor::Property::CLIPPING_MODE;
33223   jresult = (int)result;
33224   return jresult;
33225 }
33226
33227
33228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
33229   void * jresult ;
33230   Dali::Actor::Property *result = 0 ;
33231
33232   {
33233     try {
33234       result = (Dali::Actor::Property *)new Dali::Actor::Property();
33235     } catch (std::out_of_range& e) {
33236       {
33237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33238       };
33239     } catch (std::exception& e) {
33240       {
33241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33242       };
33243     } catch (Dali::DaliException e) {
33244       {
33245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33246       };
33247     } catch (...) {
33248       {
33249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33250       };
33251     }
33252   }
33253
33254   jresult = (void *)result;
33255   return jresult;
33256 }
33257
33258
33259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
33260   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
33261
33262   arg1 = (Dali::Actor::Property *)jarg1;
33263   {
33264     try {
33265       delete arg1;
33266     } catch (std::out_of_range& e) {
33267       {
33268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33269       };
33270     } catch (std::exception& e) {
33271       {
33272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33273       };
33274     } catch (Dali::DaliException e) {
33275       {
33276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33277       };
33278     } catch (...) {
33279       {
33280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33281       };
33282     }
33283   }
33284
33285 }
33286
33287
33288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
33289   void * jresult ;
33290   Dali::Actor *result = 0 ;
33291
33292   {
33293     try {
33294       result = (Dali::Actor *)new Dali::Actor();
33295     } catch (std::out_of_range& e) {
33296       {
33297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33298       };
33299     } catch (std::exception& e) {
33300       {
33301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33302       };
33303     } catch (Dali::DaliException e) {
33304       {
33305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33306       };
33307     } catch (...) {
33308       {
33309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33310       };
33311     }
33312   }
33313
33314   jresult = (void *)result;
33315   return jresult;
33316 }
33317
33318
33319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
33320   void * jresult ;
33321   Dali::Actor result;
33322
33323   {
33324     try {
33325       result = Dali::Actor::New();
33326     } catch (std::out_of_range& e) {
33327       {
33328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33329       };
33330     } catch (std::exception& e) {
33331       {
33332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33333       };
33334     } catch (Dali::DaliException e) {
33335       {
33336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33337       };
33338     } catch (...) {
33339       {
33340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33341       };
33342     }
33343   }
33344
33345   jresult = new Dali::Actor((const Dali::Actor &)result);
33346   return jresult;
33347 }
33348
33349
33350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
33351   void * jresult ;
33352   Dali::BaseHandle arg1 ;
33353   Dali::BaseHandle *argp1 ;
33354   Dali::Actor result;
33355
33356   argp1 = (Dali::BaseHandle *)jarg1;
33357   if (!argp1) {
33358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33359     return 0;
33360   }
33361   arg1 = *argp1;
33362   {
33363     try {
33364       result = Dali::Actor::DownCast(arg1);
33365     } catch (std::out_of_range& e) {
33366       {
33367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33368       };
33369     } catch (std::exception& e) {
33370       {
33371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33372       };
33373     } catch (Dali::DaliException e) {
33374       {
33375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33376       };
33377     } catch (...) {
33378       {
33379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33380       };
33381     }
33382   }
33383
33384   jresult = new Dali::Actor((const Dali::Actor &)result);
33385   return jresult;
33386 }
33387
33388
33389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
33390   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33391
33392   arg1 = (Dali::Actor *)jarg1;
33393   {
33394     try {
33395       delete arg1;
33396     } catch (std::out_of_range& e) {
33397       {
33398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33399       };
33400     } catch (std::exception& e) {
33401       {
33402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33403       };
33404     } catch (Dali::DaliException e) {
33405       {
33406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33407       };
33408     } catch (...) {
33409       {
33410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33411       };
33412     }
33413   }
33414
33415 }
33416
33417
33418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
33419   void * jresult ;
33420   Dali::Actor *arg1 = 0 ;
33421   Dali::Actor *result = 0 ;
33422
33423   arg1 = (Dali::Actor *)jarg1;
33424   if (!arg1) {
33425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33426     return 0;
33427   }
33428   {
33429     try {
33430       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
33431     } catch (std::out_of_range& e) {
33432       {
33433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33434       };
33435     } catch (std::exception& e) {
33436       {
33437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33438       };
33439     } catch (Dali::DaliException e) {
33440       {
33441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33442       };
33443     } catch (...) {
33444       {
33445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33446       };
33447     }
33448   }
33449
33450   jresult = (void *)result;
33451   return jresult;
33452 }
33453
33454
33455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
33456   void * jresult ;
33457   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33458   Dali::Actor *arg2 = 0 ;
33459   Dali::Actor *result = 0 ;
33460
33461   arg1 = (Dali::Actor *)jarg1;
33462   arg2 = (Dali::Actor *)jarg2;
33463   if (!arg2) {
33464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33465     return 0;
33466   }
33467   {
33468     try {
33469       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
33470     } catch (std::out_of_range& e) {
33471       {
33472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33473       };
33474     } catch (std::exception& e) {
33475       {
33476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33477       };
33478     } catch (Dali::DaliException e) {
33479       {
33480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33481       };
33482     } catch (...) {
33483       {
33484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33485       };
33486     }
33487   }
33488
33489   jresult = (void *)result;
33490   return jresult;
33491 }
33492
33493
33494 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
33495   char * jresult ;
33496   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33497   std::string *result = 0 ;
33498
33499   arg1 = (Dali::Actor *)jarg1;
33500   {
33501     try {
33502       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
33503     } catch (std::out_of_range& e) {
33504       {
33505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33506       };
33507     } catch (std::exception& e) {
33508       {
33509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33510       };
33511     } catch (Dali::DaliException e) {
33512       {
33513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33514       };
33515     } catch (...) {
33516       {
33517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33518       };
33519     }
33520   }
33521
33522   jresult = SWIG_csharp_string_callback(result->c_str());
33523   return jresult;
33524 }
33525
33526
33527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
33528   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33529   std::string *arg2 = 0 ;
33530
33531   arg1 = (Dali::Actor *)jarg1;
33532   if (!jarg2) {
33533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33534     return ;
33535   }
33536   std::string arg2_str(jarg2);
33537   arg2 = &arg2_str;
33538   {
33539     try {
33540       (arg1)->SetName((std::string const &)*arg2);
33541     } catch (std::out_of_range& e) {
33542       {
33543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33544       };
33545     } catch (std::exception& e) {
33546       {
33547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33548       };
33549     } catch (Dali::DaliException e) {
33550       {
33551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33552       };
33553     } catch (...) {
33554       {
33555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33556       };
33557     }
33558   }
33559
33560
33561   //argout typemap for const std::string&
33562
33563 }
33564
33565
33566 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
33567   unsigned int jresult ;
33568   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33569   unsigned int result;
33570
33571   arg1 = (Dali::Actor *)jarg1;
33572   {
33573     try {
33574       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
33575     } catch (std::out_of_range& e) {
33576       {
33577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33578       };
33579     } catch (std::exception& e) {
33580       {
33581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33582       };
33583     } catch (Dali::DaliException e) {
33584       {
33585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33586       };
33587     } catch (...) {
33588       {
33589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33590       };
33591     }
33592   }
33593
33594   jresult = result;
33595   return jresult;
33596 }
33597
33598
33599 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
33600   unsigned int jresult ;
33601   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33602   bool result;
33603
33604   arg1 = (Dali::Actor *)jarg1;
33605   {
33606     try {
33607       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
33608     } catch (std::out_of_range& e) {
33609       {
33610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33611       };
33612     } catch (std::exception& e) {
33613       {
33614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33615       };
33616     } catch (Dali::DaliException e) {
33617       {
33618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33619       };
33620     } catch (...) {
33621       {
33622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33623       };
33624     }
33625   }
33626
33627   jresult = result;
33628   return jresult;
33629 }
33630
33631
33632 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
33633   unsigned int jresult ;
33634   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33635   bool result;
33636
33637   arg1 = (Dali::Actor *)jarg1;
33638   {
33639     try {
33640       result = (bool)((Dali::Actor const *)arg1)->OnStage();
33641     } catch (std::out_of_range& e) {
33642       {
33643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33644       };
33645     } catch (std::exception& e) {
33646       {
33647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33648       };
33649     } catch (Dali::DaliException e) {
33650       {
33651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33652       };
33653     } catch (...) {
33654       {
33655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33656       };
33657     }
33658   }
33659
33660   jresult = result;
33661   return jresult;
33662 }
33663
33664
33665 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
33666   unsigned int jresult ;
33667   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33668   bool result;
33669
33670   arg1 = (Dali::Actor *)jarg1;
33671   {
33672     try {
33673       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
33674     } catch (std::out_of_range& e) {
33675       {
33676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33677       };
33678     } catch (std::exception& e) {
33679       {
33680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33681       };
33682     } catch (Dali::DaliException e) {
33683       {
33684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33685       };
33686     } catch (...) {
33687       {
33688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33689       };
33690     }
33691   }
33692
33693   jresult = result;
33694   return jresult;
33695 }
33696
33697
33698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
33699   void * jresult ;
33700   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33701   Dali::Layer result;
33702
33703   arg1 = (Dali::Actor *)jarg1;
33704   {
33705     try {
33706       result = (arg1)->GetLayer();
33707     } catch (std::out_of_range& e) {
33708       {
33709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33710       };
33711     } catch (std::exception& e) {
33712       {
33713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33714       };
33715     } catch (Dali::DaliException e) {
33716       {
33717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33718       };
33719     } catch (...) {
33720       {
33721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33722       };
33723     }
33724   }
33725
33726   jresult = new Dali::Layer((const Dali::Layer &)result);
33727   return jresult;
33728 }
33729
33730
33731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
33732   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33733   Dali::Actor arg2 ;
33734   Dali::Actor *argp2 ;
33735
33736   arg1 = (Dali::Actor *)jarg1;
33737   argp2 = (Dali::Actor *)jarg2;
33738   if (!argp2) {
33739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33740     return ;
33741   }
33742   arg2 = *argp2;
33743   {
33744     try {
33745       (arg1)->Add(arg2);
33746     } catch (std::out_of_range& e) {
33747       {
33748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33749       };
33750     } catch (std::exception& e) {
33751       {
33752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33753       };
33754     } catch (Dali::DaliException e) {
33755       {
33756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33757       };
33758     } catch (...) {
33759       {
33760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33761       };
33762     }
33763   }
33764
33765 }
33766
33767
33768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
33769   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33770   Dali::Actor arg2 ;
33771   Dali::Actor *argp2 ;
33772
33773   arg1 = (Dali::Actor *)jarg1;
33774   argp2 = (Dali::Actor *)jarg2;
33775   if (!argp2) {
33776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33777     return ;
33778   }
33779   arg2 = *argp2;
33780   {
33781     try {
33782       (arg1)->Remove(arg2);
33783     } catch (std::out_of_range& e) {
33784       {
33785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33786       };
33787     } catch (std::exception& e) {
33788       {
33789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33790       };
33791     } catch (Dali::DaliException e) {
33792       {
33793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33794       };
33795     } catch (...) {
33796       {
33797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33798       };
33799     }
33800   }
33801
33802 }
33803
33804
33805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
33806   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33807
33808   arg1 = (Dali::Actor *)jarg1;
33809   {
33810     try {
33811       (arg1)->Unparent();
33812     } catch (std::out_of_range& e) {
33813       {
33814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33815       };
33816     } catch (std::exception& e) {
33817       {
33818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33819       };
33820     } catch (Dali::DaliException e) {
33821       {
33822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33823       };
33824     } catch (...) {
33825       {
33826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33827       };
33828     }
33829   }
33830
33831 }
33832
33833
33834 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
33835   unsigned int jresult ;
33836   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33837   unsigned int result;
33838
33839   arg1 = (Dali::Actor *)jarg1;
33840   {
33841     try {
33842       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
33843     } catch (std::out_of_range& e) {
33844       {
33845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33846       };
33847     } catch (std::exception& e) {
33848       {
33849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33850       };
33851     } catch (Dali::DaliException e) {
33852       {
33853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33854       };
33855     } catch (...) {
33856       {
33857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33858       };
33859     }
33860   }
33861
33862   jresult = result;
33863   return jresult;
33864 }
33865
33866
33867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
33868   void * jresult ;
33869   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33870   unsigned int arg2 ;
33871   Dali::Actor result;
33872
33873   arg1 = (Dali::Actor *)jarg1;
33874   arg2 = (unsigned int)jarg2;
33875   {
33876     try {
33877       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
33878     } catch (std::out_of_range& e) {
33879       {
33880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33881       };
33882     } catch (std::exception& e) {
33883       {
33884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33885       };
33886     } catch (Dali::DaliException e) {
33887       {
33888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33889       };
33890     } catch (...) {
33891       {
33892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33893       };
33894     }
33895   }
33896
33897   jresult = new Dali::Actor((const Dali::Actor &)result);
33898   return jresult;
33899 }
33900
33901
33902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
33903   void * jresult ;
33904   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33905   std::string *arg2 = 0 ;
33906   Dali::Actor result;
33907
33908   arg1 = (Dali::Actor *)jarg1;
33909   if (!jarg2) {
33910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33911     return 0;
33912   }
33913   std::string arg2_str(jarg2);
33914   arg2 = &arg2_str;
33915   {
33916     try {
33917       result = (arg1)->FindChildByName((std::string const &)*arg2);
33918     } catch (std::out_of_range& e) {
33919       {
33920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33921       };
33922     } catch (std::exception& e) {
33923       {
33924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33925       };
33926     } catch (Dali::DaliException e) {
33927       {
33928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33929       };
33930     } catch (...) {
33931       {
33932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33933       };
33934     }
33935   }
33936
33937   jresult = new Dali::Actor((const Dali::Actor &)result);
33938
33939   //argout typemap for const std::string&
33940
33941   return jresult;
33942 }
33943
33944
33945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
33946   void * jresult ;
33947   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33948   unsigned int arg2 ;
33949   Dali::Actor result;
33950
33951   arg1 = (Dali::Actor *)jarg1;
33952   arg2 = (unsigned int)jarg2;
33953   {
33954     try {
33955       result = (arg1)->FindChildById(arg2);
33956     } catch (std::out_of_range& e) {
33957       {
33958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33959       };
33960     } catch (std::exception& e) {
33961       {
33962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33963       };
33964     } catch (Dali::DaliException e) {
33965       {
33966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33967       };
33968     } catch (...) {
33969       {
33970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33971       };
33972     }
33973   }
33974
33975   jresult = new Dali::Actor((const Dali::Actor &)result);
33976   return jresult;
33977 }
33978
33979
33980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
33981   void * jresult ;
33982   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33983   Dali::Actor result;
33984
33985   arg1 = (Dali::Actor *)jarg1;
33986   {
33987     try {
33988       result = ((Dali::Actor const *)arg1)->GetParent();
33989     } catch (std::out_of_range& e) {
33990       {
33991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33992       };
33993     } catch (std::exception& e) {
33994       {
33995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33996       };
33997     } catch (Dali::DaliException e) {
33998       {
33999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34000       };
34001     } catch (...) {
34002       {
34003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34004       };
34005     }
34006   }
34007
34008   jresult = new Dali::Actor((const Dali::Actor &)result);
34009   return jresult;
34010 }
34011
34012
34013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
34014   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34015   Dali::Vector3 *arg2 = 0 ;
34016
34017   arg1 = (Dali::Actor *)jarg1;
34018   arg2 = (Dali::Vector3 *)jarg2;
34019   if (!arg2) {
34020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34021     return ;
34022   }
34023   {
34024     try {
34025       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
34026     } catch (std::out_of_range& e) {
34027       {
34028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34029       };
34030     } catch (std::exception& e) {
34031       {
34032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34033       };
34034     } catch (Dali::DaliException e) {
34035       {
34036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34037       };
34038     } catch (...) {
34039       {
34040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34041       };
34042     }
34043   }
34044
34045 }
34046
34047
34048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
34049   void * jresult ;
34050   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34051   Dali::Vector3 result;
34052
34053   arg1 = (Dali::Actor *)jarg1;
34054   {
34055     try {
34056       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
34057     } catch (std::out_of_range& e) {
34058       {
34059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34060       };
34061     } catch (std::exception& e) {
34062       {
34063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34064       };
34065     } catch (Dali::DaliException e) {
34066       {
34067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34068       };
34069     } catch (...) {
34070       {
34071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34072       };
34073     }
34074   }
34075
34076   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34077   return jresult;
34078 }
34079
34080
34081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34082   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34083   Dali::Vector3 *arg2 = 0 ;
34084
34085   arg1 = (Dali::Actor *)jarg1;
34086   arg2 = (Dali::Vector3 *)jarg2;
34087   if (!arg2) {
34088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34089     return ;
34090   }
34091   {
34092     try {
34093       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
34094     } catch (std::out_of_range& e) {
34095       {
34096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34097       };
34098     } catch (std::exception& e) {
34099       {
34100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34101       };
34102     } catch (Dali::DaliException e) {
34103       {
34104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34105       };
34106     } catch (...) {
34107       {
34108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34109       };
34110     }
34111   }
34112
34113 }
34114
34115
34116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34117   void * jresult ;
34118   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34119   Dali::Vector3 result;
34120
34121   arg1 = (Dali::Actor *)jarg1;
34122   {
34123     try {
34124       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
34125     } catch (std::out_of_range& e) {
34126       {
34127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34128       };
34129     } catch (std::exception& e) {
34130       {
34131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34132       };
34133     } catch (Dali::DaliException e) {
34134       {
34135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34136       };
34137     } catch (...) {
34138       {
34139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34140       };
34141     }
34142   }
34143
34144   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34145   return jresult;
34146 }
34147
34148
34149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34150   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34151   float arg2 ;
34152   float arg3 ;
34153
34154   arg1 = (Dali::Actor *)jarg1;
34155   arg2 = (float)jarg2;
34156   arg3 = (float)jarg3;
34157   {
34158     try {
34159       (arg1)->SetSize(arg2,arg3);
34160     } catch (std::out_of_range& e) {
34161       {
34162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34163       };
34164     } catch (std::exception& e) {
34165       {
34166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34167       };
34168     } catch (Dali::DaliException e) {
34169       {
34170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34171       };
34172     } catch (...) {
34173       {
34174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34175       };
34176     }
34177   }
34178
34179 }
34180
34181
34182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34183   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34184   float arg2 ;
34185   float arg3 ;
34186   float arg4 ;
34187
34188   arg1 = (Dali::Actor *)jarg1;
34189   arg2 = (float)jarg2;
34190   arg3 = (float)jarg3;
34191   arg4 = (float)jarg4;
34192   {
34193     try {
34194       (arg1)->SetSize(arg2,arg3,arg4);
34195     } catch (std::out_of_range& e) {
34196       {
34197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34198       };
34199     } catch (std::exception& e) {
34200       {
34201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34202       };
34203     } catch (Dali::DaliException e) {
34204       {
34205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34206       };
34207     } catch (...) {
34208       {
34209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34210       };
34211     }
34212   }
34213
34214 }
34215
34216
34217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34218   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34219   Dali::Vector2 *arg2 = 0 ;
34220
34221   arg1 = (Dali::Actor *)jarg1;
34222   arg2 = (Dali::Vector2 *)jarg2;
34223   if (!arg2) {
34224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34225     return ;
34226   }
34227   {
34228     try {
34229       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
34230     } catch (std::out_of_range& e) {
34231       {
34232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34233       };
34234     } catch (std::exception& e) {
34235       {
34236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34237       };
34238     } catch (Dali::DaliException e) {
34239       {
34240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34241       };
34242     } catch (...) {
34243       {
34244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34245       };
34246     }
34247   }
34248
34249 }
34250
34251
34252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
34253   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34254   Dali::Vector3 *arg2 = 0 ;
34255
34256   arg1 = (Dali::Actor *)jarg1;
34257   arg2 = (Dali::Vector3 *)jarg2;
34258   if (!arg2) {
34259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34260     return ;
34261   }
34262   {
34263     try {
34264       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
34265     } catch (std::out_of_range& e) {
34266       {
34267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34268       };
34269     } catch (std::exception& e) {
34270       {
34271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34272       };
34273     } catch (Dali::DaliException e) {
34274       {
34275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34276       };
34277     } catch (...) {
34278       {
34279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34280       };
34281     }
34282   }
34283
34284 }
34285
34286
34287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
34288   void * jresult ;
34289   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34290   Dali::Vector3 result;
34291
34292   arg1 = (Dali::Actor *)jarg1;
34293   {
34294     try {
34295       result = ((Dali::Actor const *)arg1)->GetTargetSize();
34296     } catch (std::out_of_range& e) {
34297       {
34298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34299       };
34300     } catch (std::exception& e) {
34301       {
34302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34303       };
34304     } catch (Dali::DaliException e) {
34305       {
34306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34307       };
34308     } catch (...) {
34309       {
34310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34311       };
34312     }
34313   }
34314
34315   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34316   return jresult;
34317 }
34318
34319
34320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
34321   void * jresult ;
34322   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34323   Dali::Vector3 result;
34324
34325   arg1 = (Dali::Actor *)jarg1;
34326   {
34327     try {
34328       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
34329     } catch (std::out_of_range& e) {
34330       {
34331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34332       };
34333     } catch (std::exception& e) {
34334       {
34335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34336       };
34337     } catch (Dali::DaliException e) {
34338       {
34339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34340       };
34341     } catch (...) {
34342       {
34343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34344       };
34345     }
34346   }
34347
34348   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34349   return jresult;
34350 }
34351
34352
34353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34354   void * jresult ;
34355   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34356   Dali::Vector3 result;
34357
34358   arg1 = (Dali::Actor *)jarg1;
34359   {
34360     try {
34361       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34362     } catch (std::out_of_range& e) {
34363       {
34364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34365       };
34366     } catch (std::exception& e) {
34367       {
34368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34369       };
34370     } catch (Dali::DaliException e) {
34371       {
34372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34373       };
34374     } catch (...) {
34375       {
34376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34377       };
34378     }
34379   }
34380
34381   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34382   return jresult;
34383 }
34384
34385
34386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34387   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34388   float arg2 ;
34389   float arg3 ;
34390
34391   arg1 = (Dali::Actor *)jarg1;
34392   arg2 = (float)jarg2;
34393   arg3 = (float)jarg3;
34394   {
34395     try {
34396       (arg1)->SetPosition(arg2,arg3);
34397     } catch (std::out_of_range& e) {
34398       {
34399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34400       };
34401     } catch (std::exception& e) {
34402       {
34403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34404       };
34405     } catch (Dali::DaliException e) {
34406       {
34407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34408       };
34409     } catch (...) {
34410       {
34411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34412       };
34413     }
34414   }
34415
34416 }
34417
34418
34419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34420   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34421   float arg2 ;
34422   float arg3 ;
34423   float arg4 ;
34424
34425   arg1 = (Dali::Actor *)jarg1;
34426   arg2 = (float)jarg2;
34427   arg3 = (float)jarg3;
34428   arg4 = (float)jarg4;
34429   {
34430     try {
34431       (arg1)->SetPosition(arg2,arg3,arg4);
34432     } catch (std::out_of_range& e) {
34433       {
34434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34435       };
34436     } catch (std::exception& e) {
34437       {
34438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34439       };
34440     } catch (Dali::DaliException e) {
34441       {
34442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34443       };
34444     } catch (...) {
34445       {
34446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34447       };
34448     }
34449   }
34450
34451 }
34452
34453
34454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34455   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34456   Dali::Vector3 *arg2 = 0 ;
34457
34458   arg1 = (Dali::Actor *)jarg1;
34459   arg2 = (Dali::Vector3 *)jarg2;
34460   if (!arg2) {
34461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34462     return ;
34463   }
34464   {
34465     try {
34466       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
34467     } catch (std::out_of_range& e) {
34468       {
34469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34470       };
34471     } catch (std::exception& e) {
34472       {
34473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34474       };
34475     } catch (Dali::DaliException e) {
34476       {
34477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34478       };
34479     } catch (...) {
34480       {
34481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34482       };
34483     }
34484   }
34485
34486 }
34487
34488
34489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34490   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34491   float arg2 ;
34492
34493   arg1 = (Dali::Actor *)jarg1;
34494   arg2 = (float)jarg2;
34495   {
34496     try {
34497       (arg1)->SetX(arg2);
34498     } catch (std::out_of_range& e) {
34499       {
34500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34501       };
34502     } catch (std::exception& e) {
34503       {
34504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34505       };
34506     } catch (Dali::DaliException e) {
34507       {
34508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34509       };
34510     } catch (...) {
34511       {
34512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34513       };
34514     }
34515   }
34516
34517 }
34518
34519
34520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34521   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34522   float arg2 ;
34523
34524   arg1 = (Dali::Actor *)jarg1;
34525   arg2 = (float)jarg2;
34526   {
34527     try {
34528       (arg1)->SetY(arg2);
34529     } catch (std::out_of_range& e) {
34530       {
34531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34532       };
34533     } catch (std::exception& e) {
34534       {
34535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34536       };
34537     } catch (Dali::DaliException e) {
34538       {
34539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34540       };
34541     } catch (...) {
34542       {
34543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34544       };
34545     }
34546   }
34547
34548 }
34549
34550
34551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
34552   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34553   float arg2 ;
34554
34555   arg1 = (Dali::Actor *)jarg1;
34556   arg2 = (float)jarg2;
34557   {
34558     try {
34559       (arg1)->SetZ(arg2);
34560     } catch (std::out_of_range& e) {
34561       {
34562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34563       };
34564     } catch (std::exception& e) {
34565       {
34566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34567       };
34568     } catch (Dali::DaliException e) {
34569       {
34570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34571       };
34572     } catch (...) {
34573       {
34574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34575       };
34576     }
34577   }
34578
34579 }
34580
34581
34582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
34583   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34584   Dali::Vector3 *arg2 = 0 ;
34585
34586   arg1 = (Dali::Actor *)jarg1;
34587   arg2 = (Dali::Vector3 *)jarg2;
34588   if (!arg2) {
34589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34590     return ;
34591   }
34592   {
34593     try {
34594       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
34595     } catch (std::out_of_range& e) {
34596       {
34597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34598       };
34599     } catch (std::exception& e) {
34600       {
34601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34602       };
34603     } catch (Dali::DaliException e) {
34604       {
34605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34606       };
34607     } catch (...) {
34608       {
34609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34610       };
34611     }
34612   }
34613
34614 }
34615
34616
34617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
34618   void * jresult ;
34619   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34620   Dali::Vector3 result;
34621
34622   arg1 = (Dali::Actor *)jarg1;
34623   {
34624     try {
34625       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
34626     } catch (std::out_of_range& e) {
34627       {
34628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34629       };
34630     } catch (std::exception& e) {
34631       {
34632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34633       };
34634     } catch (Dali::DaliException e) {
34635       {
34636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34637       };
34638     } catch (...) {
34639       {
34640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34641       };
34642     }
34643   }
34644
34645   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34646   return jresult;
34647 }
34648
34649
34650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
34651   void * jresult ;
34652   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34653   Dali::Vector3 result;
34654
34655   arg1 = (Dali::Actor *)jarg1;
34656   {
34657     try {
34658       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
34659     } catch (std::out_of_range& e) {
34660       {
34661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34662       };
34663     } catch (std::exception& e) {
34664       {
34665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34666       };
34667     } catch (Dali::DaliException e) {
34668       {
34669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34670       };
34671     } catch (...) {
34672       {
34673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34674       };
34675     }
34676   }
34677
34678   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34679   return jresult;
34680 }
34681
34682
34683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
34684   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34685   bool arg2 ;
34686
34687   arg1 = (Dali::Actor *)jarg1;
34688   arg2 = jarg2 ? true : false;
34689   {
34690     try {
34691       (arg1)->SetInheritPosition(arg2);
34692     } catch (std::out_of_range& e) {
34693       {
34694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34695       };
34696     } catch (std::exception& e) {
34697       {
34698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34699       };
34700     } catch (Dali::DaliException e) {
34701       {
34702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34703       };
34704     } catch (...) {
34705       {
34706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34707       };
34708     }
34709   }
34710
34711 }
34712
34713
34714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetPositionInheritanceMode(void * jarg1) {
34715   int jresult ;
34716   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34717   Dali::PositionInheritanceMode result;
34718
34719   arg1 = (Dali::Actor *)jarg1;
34720   {
34721     try {
34722       result = (Dali::PositionInheritanceMode)((Dali::Actor const *)arg1)->GetPositionInheritanceMode();
34723     } catch (std::out_of_range& e) {
34724       {
34725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34726       };
34727     } catch (std::exception& e) {
34728       {
34729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34730       };
34731     } catch (Dali::DaliException e) {
34732       {
34733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34734       };
34735     } catch (...) {
34736       {
34737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34738       };
34739     }
34740   }
34741
34742   jresult = (int)result;
34743   return jresult;
34744 }
34745
34746
34747 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
34748   unsigned int jresult ;
34749   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34750   bool result;
34751
34752   arg1 = (Dali::Actor *)jarg1;
34753   {
34754     try {
34755       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
34756     } catch (std::out_of_range& e) {
34757       {
34758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34759       };
34760     } catch (std::exception& e) {
34761       {
34762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34763       };
34764     } catch (Dali::DaliException e) {
34765       {
34766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34767       };
34768     } catch (...) {
34769       {
34770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34771       };
34772     }
34773   }
34774
34775   jresult = result;
34776   return jresult;
34777 }
34778
34779
34780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34781   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34782   Dali::Degree *arg2 = 0 ;
34783   Dali::Vector3 *arg3 = 0 ;
34784
34785   arg1 = (Dali::Actor *)jarg1;
34786   arg2 = (Dali::Degree *)jarg2;
34787   if (!arg2) {
34788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34789     return ;
34790   }
34791   arg3 = (Dali::Vector3 *)jarg3;
34792   if (!arg3) {
34793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34794     return ;
34795   }
34796   {
34797     try {
34798       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
34799     } catch (std::out_of_range& e) {
34800       {
34801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34802       };
34803     } catch (std::exception& e) {
34804       {
34805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34806       };
34807     } catch (Dali::DaliException e) {
34808       {
34809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34810       };
34811     } catch (...) {
34812       {
34813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34814       };
34815     }
34816   }
34817
34818 }
34819
34820
34821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
34822   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34823   Dali::Radian *arg2 = 0 ;
34824   Dali::Vector3 *arg3 = 0 ;
34825
34826   arg1 = (Dali::Actor *)jarg1;
34827   arg2 = (Dali::Radian *)jarg2;
34828   if (!arg2) {
34829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
34830     return ;
34831   }
34832   arg3 = (Dali::Vector3 *)jarg3;
34833   if (!arg3) {
34834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34835     return ;
34836   }
34837   {
34838     try {
34839       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
34840     } catch (std::out_of_range& e) {
34841       {
34842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34843       };
34844     } catch (std::exception& e) {
34845       {
34846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34847       };
34848     } catch (Dali::DaliException e) {
34849       {
34850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34851       };
34852     } catch (...) {
34853       {
34854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34855       };
34856     }
34857   }
34858
34859 }
34860
34861
34862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
34863   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34864   Dali::Quaternion *arg2 = 0 ;
34865
34866   arg1 = (Dali::Actor *)jarg1;
34867   arg2 = (Dali::Quaternion *)jarg2;
34868   if (!arg2) {
34869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
34870     return ;
34871   }
34872   {
34873     try {
34874       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
34875     } catch (std::out_of_range& e) {
34876       {
34877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34878       };
34879     } catch (std::exception& e) {
34880       {
34881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34882       };
34883     } catch (Dali::DaliException e) {
34884       {
34885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34886       };
34887     } catch (...) {
34888       {
34889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34890       };
34891     }
34892   }
34893
34894 }
34895
34896
34897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34898   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34899   Dali::Degree *arg2 = 0 ;
34900   Dali::Vector3 *arg3 = 0 ;
34901
34902   arg1 = (Dali::Actor *)jarg1;
34903   arg2 = (Dali::Degree *)jarg2;
34904   if (!arg2) {
34905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34906     return ;
34907   }
34908   arg3 = (Dali::Vector3 *)jarg3;
34909   if (!arg3) {
34910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34911     return ;
34912   }
34913   {
34914     try {
34915       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
34916     } catch (std::out_of_range& e) {
34917       {
34918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34919       };
34920     } catch (std::exception& e) {
34921       {
34922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34923       };
34924     } catch (Dali::DaliException e) {
34925       {
34926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34927       };
34928     } catch (...) {
34929       {
34930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34931       };
34932     }
34933   }
34934
34935 }
34936
34937
34938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
34939   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34940   Dali::Radian *arg2 = 0 ;
34941   Dali::Vector3 *arg3 = 0 ;
34942
34943   arg1 = (Dali::Actor *)jarg1;
34944   arg2 = (Dali::Radian *)jarg2;
34945   if (!arg2) {
34946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
34947     return ;
34948   }
34949   arg3 = (Dali::Vector3 *)jarg3;
34950   if (!arg3) {
34951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34952     return ;
34953   }
34954   {
34955     try {
34956       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
34957     } catch (std::out_of_range& e) {
34958       {
34959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34960       };
34961     } catch (std::exception& e) {
34962       {
34963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34964       };
34965     } catch (Dali::DaliException e) {
34966       {
34967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34968       };
34969     } catch (...) {
34970       {
34971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34972       };
34973     }
34974   }
34975
34976 }
34977
34978
34979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
34980   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34981   Dali::Quaternion *arg2 = 0 ;
34982
34983   arg1 = (Dali::Actor *)jarg1;
34984   arg2 = (Dali::Quaternion *)jarg2;
34985   if (!arg2) {
34986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
34987     return ;
34988   }
34989   {
34990     try {
34991       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
34992     } catch (std::out_of_range& e) {
34993       {
34994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34995       };
34996     } catch (std::exception& e) {
34997       {
34998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34999       };
35000     } catch (Dali::DaliException e) {
35001       {
35002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35003       };
35004     } catch (...) {
35005       {
35006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35007       };
35008     }
35009   }
35010
35011 }
35012
35013
35014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
35015   void * jresult ;
35016   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35017   Dali::Quaternion result;
35018
35019   arg1 = (Dali::Actor *)jarg1;
35020   {
35021     try {
35022       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
35023     } catch (std::out_of_range& e) {
35024       {
35025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35026       };
35027     } catch (std::exception& e) {
35028       {
35029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35030       };
35031     } catch (Dali::DaliException e) {
35032       {
35033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35034       };
35035     } catch (...) {
35036       {
35037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35038       };
35039     }
35040   }
35041
35042   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35043   return jresult;
35044 }
35045
35046
35047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
35048   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35049   bool arg2 ;
35050
35051   arg1 = (Dali::Actor *)jarg1;
35052   arg2 = jarg2 ? true : false;
35053   {
35054     try {
35055       (arg1)->SetInheritOrientation(arg2);
35056     } catch (std::out_of_range& e) {
35057       {
35058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35059       };
35060     } catch (std::exception& e) {
35061       {
35062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35063       };
35064     } catch (Dali::DaliException e) {
35065       {
35066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35067       };
35068     } catch (...) {
35069       {
35070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35071       };
35072     }
35073   }
35074
35075 }
35076
35077
35078 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
35079   unsigned int jresult ;
35080   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35081   bool result;
35082
35083   arg1 = (Dali::Actor *)jarg1;
35084   {
35085     try {
35086       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
35087     } catch (std::out_of_range& e) {
35088       {
35089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35090       };
35091     } catch (std::exception& e) {
35092       {
35093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35094       };
35095     } catch (Dali::DaliException e) {
35096       {
35097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35098       };
35099     } catch (...) {
35100       {
35101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35102       };
35103     }
35104   }
35105
35106   jresult = result;
35107   return jresult;
35108 }
35109
35110
35111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35112   void * jresult ;
35113   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35114   Dali::Quaternion result;
35115
35116   arg1 = (Dali::Actor *)jarg1;
35117   {
35118     try {
35119       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
35120     } catch (std::out_of_range& e) {
35121       {
35122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35123       };
35124     } catch (std::exception& e) {
35125       {
35126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35127       };
35128     } catch (Dali::DaliException e) {
35129       {
35130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35131       };
35132     } catch (...) {
35133       {
35134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35135       };
35136     }
35137   }
35138
35139   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35140   return jresult;
35141 }
35142
35143
35144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35145   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35146   float arg2 ;
35147
35148   arg1 = (Dali::Actor *)jarg1;
35149   arg2 = (float)jarg2;
35150   {
35151     try {
35152       (arg1)->SetScale(arg2);
35153     } catch (std::out_of_range& e) {
35154       {
35155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35156       };
35157     } catch (std::exception& e) {
35158       {
35159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35160       };
35161     } catch (Dali::DaliException e) {
35162       {
35163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35164       };
35165     } catch (...) {
35166       {
35167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35168       };
35169     }
35170   }
35171
35172 }
35173
35174
35175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35176   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35177   float arg2 ;
35178   float arg3 ;
35179   float arg4 ;
35180
35181   arg1 = (Dali::Actor *)jarg1;
35182   arg2 = (float)jarg2;
35183   arg3 = (float)jarg3;
35184   arg4 = (float)jarg4;
35185   {
35186     try {
35187       (arg1)->SetScale(arg2,arg3,arg4);
35188     } catch (std::out_of_range& e) {
35189       {
35190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35191       };
35192     } catch (std::exception& e) {
35193       {
35194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35195       };
35196     } catch (Dali::DaliException e) {
35197       {
35198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35199       };
35200     } catch (...) {
35201       {
35202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35203       };
35204     }
35205   }
35206
35207 }
35208
35209
35210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35211   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35212   Dali::Vector3 *arg2 = 0 ;
35213
35214   arg1 = (Dali::Actor *)jarg1;
35215   arg2 = (Dali::Vector3 *)jarg2;
35216   if (!arg2) {
35217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35218     return ;
35219   }
35220   {
35221     try {
35222       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
35223     } catch (std::out_of_range& e) {
35224       {
35225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35226       };
35227     } catch (std::exception& e) {
35228       {
35229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35230       };
35231     } catch (Dali::DaliException e) {
35232       {
35233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35234       };
35235     } catch (...) {
35236       {
35237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35238       };
35239     }
35240   }
35241
35242 }
35243
35244
35245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35246   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35247   Dali::Vector3 *arg2 = 0 ;
35248
35249   arg1 = (Dali::Actor *)jarg1;
35250   arg2 = (Dali::Vector3 *)jarg2;
35251   if (!arg2) {
35252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35253     return ;
35254   }
35255   {
35256     try {
35257       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35258     } catch (std::out_of_range& e) {
35259       {
35260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35261       };
35262     } catch (std::exception& e) {
35263       {
35264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35265       };
35266     } catch (Dali::DaliException e) {
35267       {
35268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35269       };
35270     } catch (...) {
35271       {
35272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35273       };
35274     }
35275   }
35276
35277 }
35278
35279
35280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35281   void * jresult ;
35282   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35283   Dali::Vector3 result;
35284
35285   arg1 = (Dali::Actor *)jarg1;
35286   {
35287     try {
35288       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
35289     } catch (std::out_of_range& e) {
35290       {
35291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35292       };
35293     } catch (std::exception& e) {
35294       {
35295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35296       };
35297     } catch (Dali::DaliException e) {
35298       {
35299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35300       };
35301     } catch (...) {
35302       {
35303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35304       };
35305     }
35306   }
35307
35308   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35309   return jresult;
35310 }
35311
35312
35313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35314   void * jresult ;
35315   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35316   Dali::Vector3 result;
35317
35318   arg1 = (Dali::Actor *)jarg1;
35319   {
35320     try {
35321       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
35322     } catch (std::out_of_range& e) {
35323       {
35324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35325       };
35326     } catch (std::exception& e) {
35327       {
35328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35329       };
35330     } catch (Dali::DaliException e) {
35331       {
35332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35333       };
35334     } catch (...) {
35335       {
35336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35337       };
35338     }
35339   }
35340
35341   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35342   return jresult;
35343 }
35344
35345
35346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35347   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35348   bool arg2 ;
35349
35350   arg1 = (Dali::Actor *)jarg1;
35351   arg2 = jarg2 ? true : false;
35352   {
35353     try {
35354       (arg1)->SetInheritScale(arg2);
35355     } catch (std::out_of_range& e) {
35356       {
35357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35358       };
35359     } catch (std::exception& e) {
35360       {
35361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35362       };
35363     } catch (Dali::DaliException e) {
35364       {
35365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35366       };
35367     } catch (...) {
35368       {
35369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35370       };
35371     }
35372   }
35373
35374 }
35375
35376
35377 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35378   unsigned int jresult ;
35379   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35380   bool result;
35381
35382   arg1 = (Dali::Actor *)jarg1;
35383   {
35384     try {
35385       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
35386     } catch (std::out_of_range& e) {
35387       {
35388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35389       };
35390     } catch (std::exception& e) {
35391       {
35392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35393       };
35394     } catch (Dali::DaliException e) {
35395       {
35396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35397       };
35398     } catch (...) {
35399       {
35400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35401       };
35402     }
35403   }
35404
35405   jresult = result;
35406   return jresult;
35407 }
35408
35409
35410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35411   void * jresult ;
35412   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35413   Dali::Matrix result;
35414
35415   arg1 = (Dali::Actor *)jarg1;
35416   {
35417     try {
35418       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
35419     } catch (std::out_of_range& e) {
35420       {
35421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35422       };
35423     } catch (std::exception& e) {
35424       {
35425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35426       };
35427     } catch (Dali::DaliException e) {
35428       {
35429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35430       };
35431     } catch (...) {
35432       {
35433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35434       };
35435     }
35436   }
35437
35438   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35439   return jresult;
35440 }
35441
35442
35443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35444   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35445   bool arg2 ;
35446
35447   arg1 = (Dali::Actor *)jarg1;
35448   arg2 = jarg2 ? true : false;
35449   {
35450     try {
35451       (arg1)->SetVisible(arg2);
35452     } catch (std::out_of_range& e) {
35453       {
35454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35455       };
35456     } catch (std::exception& e) {
35457       {
35458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35459       };
35460     } catch (Dali::DaliException e) {
35461       {
35462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35463       };
35464     } catch (...) {
35465       {
35466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35467       };
35468     }
35469   }
35470
35471 }
35472
35473
35474 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35475   unsigned int jresult ;
35476   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35477   bool result;
35478
35479   arg1 = (Dali::Actor *)jarg1;
35480   {
35481     try {
35482       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
35483     } catch (std::out_of_range& e) {
35484       {
35485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35486       };
35487     } catch (std::exception& e) {
35488       {
35489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35490       };
35491     } catch (Dali::DaliException e) {
35492       {
35493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35494       };
35495     } catch (...) {
35496       {
35497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35498       };
35499     }
35500   }
35501
35502   jresult = result;
35503   return jresult;
35504 }
35505
35506
35507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35508   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35509   float arg2 ;
35510
35511   arg1 = (Dali::Actor *)jarg1;
35512   arg2 = (float)jarg2;
35513   {
35514     try {
35515       (arg1)->SetOpacity(arg2);
35516     } catch (std::out_of_range& e) {
35517       {
35518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35519       };
35520     } catch (std::exception& e) {
35521       {
35522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35523       };
35524     } catch (Dali::DaliException e) {
35525       {
35526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35527       };
35528     } catch (...) {
35529       {
35530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35531       };
35532     }
35533   }
35534
35535 }
35536
35537
35538 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35539   float jresult ;
35540   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35541   float result;
35542
35543   arg1 = (Dali::Actor *)jarg1;
35544   {
35545     try {
35546       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
35547     } catch (std::out_of_range& e) {
35548       {
35549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35550       };
35551     } catch (std::exception& e) {
35552       {
35553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35554       };
35555     } catch (Dali::DaliException e) {
35556       {
35557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35558       };
35559     } catch (...) {
35560       {
35561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35562       };
35563     }
35564   }
35565
35566   jresult = result;
35567   return jresult;
35568 }
35569
35570
35571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
35572   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35573   Dali::Vector4 *arg2 = 0 ;
35574
35575   arg1 = (Dali::Actor *)jarg1;
35576   arg2 = (Dali::Vector4 *)jarg2;
35577   if (!arg2) {
35578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35579     return ;
35580   }
35581   {
35582     try {
35583       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
35584     } catch (std::out_of_range& e) {
35585       {
35586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35587       };
35588     } catch (std::exception& e) {
35589       {
35590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35591       };
35592     } catch (Dali::DaliException e) {
35593       {
35594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35595       };
35596     } catch (...) {
35597       {
35598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35599       };
35600     }
35601   }
35602
35603 }
35604
35605
35606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
35607   void * jresult ;
35608   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35609   Dali::Vector4 result;
35610
35611   arg1 = (Dali::Actor *)jarg1;
35612   {
35613     try {
35614       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
35615     } catch (std::out_of_range& e) {
35616       {
35617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35618       };
35619     } catch (std::exception& e) {
35620       {
35621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35622       };
35623     } catch (Dali::DaliException e) {
35624       {
35625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35626       };
35627     } catch (...) {
35628       {
35629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35630       };
35631     }
35632   }
35633
35634   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35635   return jresult;
35636 }
35637
35638
35639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
35640   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35641   Dali::ColorMode arg2 ;
35642
35643   arg1 = (Dali::Actor *)jarg1;
35644   arg2 = (Dali::ColorMode)jarg2;
35645   {
35646     try {
35647       (arg1)->SetColorMode(arg2);
35648     } catch (std::out_of_range& e) {
35649       {
35650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35651       };
35652     } catch (std::exception& e) {
35653       {
35654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35655       };
35656     } catch (Dali::DaliException e) {
35657       {
35658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35659       };
35660     } catch (...) {
35661       {
35662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35663       };
35664     }
35665   }
35666
35667 }
35668
35669
35670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
35671   int jresult ;
35672   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35673   Dali::ColorMode result;
35674
35675   arg1 = (Dali::Actor *)jarg1;
35676   {
35677     try {
35678       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
35679     } catch (std::out_of_range& e) {
35680       {
35681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35682       };
35683     } catch (std::exception& e) {
35684       {
35685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35686       };
35687     } catch (Dali::DaliException e) {
35688       {
35689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35690       };
35691     } catch (...) {
35692       {
35693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35694       };
35695     }
35696   }
35697
35698   jresult = (int)result;
35699   return jresult;
35700 }
35701
35702
35703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
35704   void * jresult ;
35705   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35706   Dali::Vector4 result;
35707
35708   arg1 = (Dali::Actor *)jarg1;
35709   {
35710     try {
35711       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
35712     } catch (std::out_of_range& e) {
35713       {
35714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35715       };
35716     } catch (std::exception& e) {
35717       {
35718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35719       };
35720     } catch (Dali::DaliException e) {
35721       {
35722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35723       };
35724     } catch (...) {
35725       {
35726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35727       };
35728     }
35729   }
35730
35731   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35732   return jresult;
35733 }
35734
35735
35736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
35737   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35738   Dali::DrawMode::Type arg2 ;
35739
35740   arg1 = (Dali::Actor *)jarg1;
35741   arg2 = (Dali::DrawMode::Type)jarg2;
35742   {
35743     try {
35744       (arg1)->SetDrawMode(arg2);
35745     } catch (std::out_of_range& e) {
35746       {
35747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35748       };
35749     } catch (std::exception& e) {
35750       {
35751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35752       };
35753     } catch (Dali::DaliException e) {
35754       {
35755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35756       };
35757     } catch (...) {
35758       {
35759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35760       };
35761     }
35762   }
35763
35764 }
35765
35766
35767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
35768   int jresult ;
35769   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35770   Dali::DrawMode::Type result;
35771
35772   arg1 = (Dali::Actor *)jarg1;
35773   {
35774     try {
35775       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
35776     } catch (std::out_of_range& e) {
35777       {
35778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35779       };
35780     } catch (std::exception& e) {
35781       {
35782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35783       };
35784     } catch (Dali::DaliException e) {
35785       {
35786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35787       };
35788     } catch (...) {
35789       {
35790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35791       };
35792     }
35793   }
35794
35795   jresult = (int)result;
35796   return jresult;
35797 }
35798
35799
35800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
35801   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35802   bool arg2 ;
35803
35804   arg1 = (Dali::Actor *)jarg1;
35805   arg2 = jarg2 ? true : false;
35806   {
35807     try {
35808       (arg1)->SetSensitive(arg2);
35809     } catch (std::out_of_range& e) {
35810       {
35811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35812       };
35813     } catch (std::exception& e) {
35814       {
35815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35816       };
35817     } catch (Dali::DaliException e) {
35818       {
35819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35820       };
35821     } catch (...) {
35822       {
35823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35824       };
35825     }
35826   }
35827
35828 }
35829
35830
35831 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
35832   unsigned int jresult ;
35833   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35834   bool result;
35835
35836   arg1 = (Dali::Actor *)jarg1;
35837   {
35838     try {
35839       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
35840     } catch (std::out_of_range& e) {
35841       {
35842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35843       };
35844     } catch (std::exception& e) {
35845       {
35846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35847       };
35848     } catch (Dali::DaliException e) {
35849       {
35850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35851       };
35852     } catch (...) {
35853       {
35854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35855       };
35856     }
35857   }
35858
35859   jresult = result;
35860   return jresult;
35861 }
35862
35863
35864 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
35865   unsigned int jresult ;
35866   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35867   float *arg2 = 0 ;
35868   float *arg3 = 0 ;
35869   float arg4 ;
35870   float arg5 ;
35871   bool result;
35872
35873   arg1 = (Dali::Actor *)jarg1;
35874   arg2 = (float *)jarg2;
35875   arg3 = (float *)jarg3;
35876   arg4 = (float)jarg4;
35877   arg5 = (float)jarg5;
35878   {
35879     try {
35880       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
35881     } catch (std::out_of_range& e) {
35882       {
35883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35884       };
35885     } catch (std::exception& e) {
35886       {
35887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35888       };
35889     } catch (Dali::DaliException e) {
35890       {
35891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35892       };
35893     } catch (...) {
35894       {
35895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35896       };
35897     }
35898   }
35899
35900   jresult = result;
35901   return jresult;
35902 }
35903
35904
35905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
35906   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35907   bool arg2 ;
35908
35909   arg1 = (Dali::Actor *)jarg1;
35910   arg2 = jarg2 ? true : false;
35911   {
35912     try {
35913       (arg1)->SetLeaveRequired(arg2);
35914     } catch (std::out_of_range& e) {
35915       {
35916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35917       };
35918     } catch (std::exception& e) {
35919       {
35920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35921       };
35922     } catch (Dali::DaliException e) {
35923       {
35924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35925       };
35926     } catch (...) {
35927       {
35928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35929       };
35930     }
35931   }
35932
35933 }
35934
35935
35936 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
35937   unsigned int jresult ;
35938   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35939   bool result;
35940
35941   arg1 = (Dali::Actor *)jarg1;
35942   {
35943     try {
35944       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
35945     } catch (std::out_of_range& e) {
35946       {
35947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35948       };
35949     } catch (std::exception& e) {
35950       {
35951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35952       };
35953     } catch (Dali::DaliException e) {
35954       {
35955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35956       };
35957     } catch (...) {
35958       {
35959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35960       };
35961     }
35962   }
35963
35964   jresult = result;
35965   return jresult;
35966 }
35967
35968
35969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
35970   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35971   bool arg2 ;
35972
35973   arg1 = (Dali::Actor *)jarg1;
35974   arg2 = jarg2 ? true : false;
35975   {
35976     try {
35977       (arg1)->SetKeyboardFocusable(arg2);
35978     } catch (std::out_of_range& e) {
35979       {
35980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35981       };
35982     } catch (std::exception& e) {
35983       {
35984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35985       };
35986     } catch (Dali::DaliException e) {
35987       {
35988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35989       };
35990     } catch (...) {
35991       {
35992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35993       };
35994     }
35995   }
35996
35997 }
35998
35999
36000 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
36001   unsigned int jresult ;
36002   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36003   bool result;
36004
36005   arg1 = (Dali::Actor *)jarg1;
36006   {
36007     try {
36008       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
36009     } catch (std::out_of_range& e) {
36010       {
36011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36012       };
36013     } catch (std::exception& e) {
36014       {
36015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36016       };
36017     } catch (Dali::DaliException e) {
36018       {
36019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36020       };
36021     } catch (...) {
36022       {
36023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36024       };
36025     }
36026   }
36027
36028   jresult = result;
36029   return jresult;
36030 }
36031
36032
36033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36034   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36035   Dali::ResizePolicy::Type arg2 ;
36036   Dali::Dimension::Type arg3 ;
36037
36038   arg1 = (Dali::Actor *)jarg1;
36039   arg2 = (Dali::ResizePolicy::Type)jarg2;
36040   arg3 = (Dali::Dimension::Type)jarg3;
36041   {
36042     try {
36043       (arg1)->SetResizePolicy(arg2,arg3);
36044     } catch (std::out_of_range& e) {
36045       {
36046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36047       };
36048     } catch (std::exception& e) {
36049       {
36050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36051       };
36052     } catch (Dali::DaliException e) {
36053       {
36054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36055       };
36056     } catch (...) {
36057       {
36058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36059       };
36060     }
36061   }
36062
36063 }
36064
36065
36066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
36067   int jresult ;
36068   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36069   Dali::Dimension::Type arg2 ;
36070   Dali::ResizePolicy::Type result;
36071
36072   arg1 = (Dali::Actor *)jarg1;
36073   arg2 = (Dali::Dimension::Type)jarg2;
36074   {
36075     try {
36076       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
36077     } catch (std::out_of_range& e) {
36078       {
36079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36080       };
36081     } catch (std::exception& e) {
36082       {
36083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36084       };
36085     } catch (Dali::DaliException e) {
36086       {
36087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36088       };
36089     } catch (...) {
36090       {
36091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36092       };
36093     }
36094   }
36095
36096   jresult = (int)result;
36097   return jresult;
36098 }
36099
36100
36101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36102   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36103   Dali::SizeScalePolicy::Type arg2 ;
36104
36105   arg1 = (Dali::Actor *)jarg1;
36106   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36107   {
36108     try {
36109       (arg1)->SetSizeScalePolicy(arg2);
36110     } catch (std::out_of_range& e) {
36111       {
36112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36113       };
36114     } catch (std::exception& e) {
36115       {
36116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36117       };
36118     } catch (Dali::DaliException e) {
36119       {
36120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36121       };
36122     } catch (...) {
36123       {
36124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36125       };
36126     }
36127   }
36128
36129 }
36130
36131
36132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36133   int jresult ;
36134   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36135   Dali::SizeScalePolicy::Type result;
36136
36137   arg1 = (Dali::Actor *)jarg1;
36138   {
36139     try {
36140       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
36141     } catch (std::out_of_range& e) {
36142       {
36143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36144       };
36145     } catch (std::exception& e) {
36146       {
36147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36148       };
36149     } catch (Dali::DaliException e) {
36150       {
36151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36152       };
36153     } catch (...) {
36154       {
36155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36156       };
36157     }
36158   }
36159
36160   jresult = (int)result;
36161   return jresult;
36162 }
36163
36164
36165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36166   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36167   Dali::Vector3 *arg2 = 0 ;
36168
36169   arg1 = (Dali::Actor *)jarg1;
36170   arg2 = (Dali::Vector3 *)jarg2;
36171   if (!arg2) {
36172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36173     return ;
36174   }
36175   {
36176     try {
36177       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
36178     } catch (std::out_of_range& e) {
36179       {
36180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36181       };
36182     } catch (std::exception& e) {
36183       {
36184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36185       };
36186     } catch (Dali::DaliException e) {
36187       {
36188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36189       };
36190     } catch (...) {
36191       {
36192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36193       };
36194     }
36195   }
36196
36197 }
36198
36199
36200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36201   void * jresult ;
36202   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36203   Dali::Vector3 result;
36204
36205   arg1 = (Dali::Actor *)jarg1;
36206   {
36207     try {
36208       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
36209     } catch (std::out_of_range& e) {
36210       {
36211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36212       };
36213     } catch (std::exception& e) {
36214       {
36215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36216       };
36217     } catch (Dali::DaliException e) {
36218       {
36219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36220       };
36221     } catch (...) {
36222       {
36223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36224       };
36225     }
36226   }
36227
36228   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36229   return jresult;
36230 }
36231
36232
36233 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36234   float jresult ;
36235   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36236   float arg2 ;
36237   float result;
36238
36239   arg1 = (Dali::Actor *)jarg1;
36240   arg2 = (float)jarg2;
36241   {
36242     try {
36243       result = (float)(arg1)->GetHeightForWidth(arg2);
36244     } catch (std::out_of_range& e) {
36245       {
36246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36247       };
36248     } catch (std::exception& e) {
36249       {
36250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36251       };
36252     } catch (Dali::DaliException e) {
36253       {
36254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36255       };
36256     } catch (...) {
36257       {
36258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36259       };
36260     }
36261   }
36262
36263   jresult = result;
36264   return jresult;
36265 }
36266
36267
36268 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36269   float jresult ;
36270   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36271   float arg2 ;
36272   float result;
36273
36274   arg1 = (Dali::Actor *)jarg1;
36275   arg2 = (float)jarg2;
36276   {
36277     try {
36278       result = (float)(arg1)->GetWidthForHeight(arg2);
36279     } catch (std::out_of_range& e) {
36280       {
36281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36282       };
36283     } catch (std::exception& e) {
36284       {
36285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36286       };
36287     } catch (Dali::DaliException e) {
36288       {
36289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36290       };
36291     } catch (...) {
36292       {
36293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36294       };
36295     }
36296   }
36297
36298   jresult = result;
36299   return jresult;
36300 }
36301
36302
36303 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36304   float jresult ;
36305   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36306   Dali::Dimension::Type arg2 ;
36307   float result;
36308
36309   arg1 = (Dali::Actor *)jarg1;
36310   arg2 = (Dali::Dimension::Type)jarg2;
36311   {
36312     try {
36313       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36314     } catch (std::out_of_range& e) {
36315       {
36316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36317       };
36318     } catch (std::exception& e) {
36319       {
36320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36321       };
36322     } catch (Dali::DaliException e) {
36323       {
36324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36325       };
36326     } catch (...) {
36327       {
36328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36329       };
36330     }
36331   }
36332
36333   jresult = result;
36334   return jresult;
36335 }
36336
36337
36338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36339   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36340   Dali::Padding *arg2 = 0 ;
36341
36342   arg1 = (Dali::Actor *)jarg1;
36343   arg2 = (Dali::Padding *)jarg2;
36344   if (!arg2) {
36345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36346     return ;
36347   }
36348   {
36349     try {
36350       (arg1)->SetPadding((Dali::Padding const &)*arg2);
36351     } catch (std::out_of_range& e) {
36352       {
36353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36354       };
36355     } catch (std::exception& e) {
36356       {
36357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36358       };
36359     } catch (Dali::DaliException e) {
36360       {
36361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36362       };
36363     } catch (...) {
36364       {
36365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36366       };
36367     }
36368   }
36369
36370 }
36371
36372
36373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36374   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36375   Dali::Padding *arg2 = 0 ;
36376
36377   arg1 = (Dali::Actor *)jarg1;
36378   arg2 = (Dali::Padding *)jarg2;
36379   if (!arg2) {
36380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36381     return ;
36382   }
36383   {
36384     try {
36385       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
36386     } catch (std::out_of_range& e) {
36387       {
36388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36389       };
36390     } catch (std::exception& e) {
36391       {
36392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36393       };
36394     } catch (Dali::DaliException e) {
36395       {
36396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36397       };
36398     } catch (...) {
36399       {
36400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36401       };
36402     }
36403   }
36404
36405 }
36406
36407
36408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36409   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36410   Dali::Vector2 *arg2 = 0 ;
36411
36412   arg1 = (Dali::Actor *)jarg1;
36413   arg2 = (Dali::Vector2 *)jarg2;
36414   if (!arg2) {
36415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36416     return ;
36417   }
36418   {
36419     try {
36420       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
36421     } catch (std::out_of_range& e) {
36422       {
36423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36424       };
36425     } catch (std::exception& e) {
36426       {
36427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36428       };
36429     } catch (Dali::DaliException e) {
36430       {
36431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36432       };
36433     } catch (...) {
36434       {
36435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36436       };
36437     }
36438   }
36439
36440 }
36441
36442
36443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36444   void * jresult ;
36445   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36446   Dali::Vector2 result;
36447
36448   arg1 = (Dali::Actor *)jarg1;
36449   {
36450     try {
36451       result = (arg1)->GetMinimumSize();
36452     } catch (std::out_of_range& e) {
36453       {
36454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36455       };
36456     } catch (std::exception& e) {
36457       {
36458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36459       };
36460     } catch (Dali::DaliException e) {
36461       {
36462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36463       };
36464     } catch (...) {
36465       {
36466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36467       };
36468     }
36469   }
36470
36471   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36472   return jresult;
36473 }
36474
36475
36476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36477   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36478   Dali::Vector2 *arg2 = 0 ;
36479
36480   arg1 = (Dali::Actor *)jarg1;
36481   arg2 = (Dali::Vector2 *)jarg2;
36482   if (!arg2) {
36483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36484     return ;
36485   }
36486   {
36487     try {
36488       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
36489     } catch (std::out_of_range& e) {
36490       {
36491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36492       };
36493     } catch (std::exception& e) {
36494       {
36495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36496       };
36497     } catch (Dali::DaliException e) {
36498       {
36499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36500       };
36501     } catch (...) {
36502       {
36503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36504       };
36505     }
36506   }
36507
36508 }
36509
36510
36511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36512   void * jresult ;
36513   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36514   Dali::Vector2 result;
36515
36516   arg1 = (Dali::Actor *)jarg1;
36517   {
36518     try {
36519       result = (arg1)->GetMaximumSize();
36520     } catch (std::out_of_range& e) {
36521       {
36522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36523       };
36524     } catch (std::exception& e) {
36525       {
36526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36527       };
36528     } catch (Dali::DaliException e) {
36529       {
36530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36531       };
36532     } catch (...) {
36533       {
36534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36535       };
36536     }
36537   }
36538
36539   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36540   return jresult;
36541 }
36542
36543
36544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36545   int jresult ;
36546   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36547   int result;
36548
36549   arg1 = (Dali::Actor *)jarg1;
36550   {
36551     try {
36552       result = (int)(arg1)->GetHierarchyDepth();
36553     } catch (std::out_of_range& e) {
36554       {
36555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36556       };
36557     } catch (std::exception& e) {
36558       {
36559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36560       };
36561     } catch (Dali::DaliException e) {
36562       {
36563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36564       };
36565     } catch (...) {
36566       {
36567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36568       };
36569     }
36570   }
36571
36572   jresult = result;
36573   return jresult;
36574 }
36575
36576
36577 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
36578   unsigned int jresult ;
36579   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36580   Dali::Renderer *arg2 = 0 ;
36581   unsigned int result;
36582
36583   arg1 = (Dali::Actor *)jarg1;
36584   arg2 = (Dali::Renderer *)jarg2;
36585   if (!arg2) {
36586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36587     return 0;
36588   }
36589   {
36590     try {
36591       result = (unsigned int)(arg1)->AddRenderer(*arg2);
36592     } catch (std::out_of_range& e) {
36593       {
36594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36595       };
36596     } catch (std::exception& e) {
36597       {
36598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36599       };
36600     } catch (Dali::DaliException e) {
36601       {
36602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36603       };
36604     } catch (...) {
36605       {
36606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36607       };
36608     }
36609   }
36610
36611   jresult = result;
36612   return jresult;
36613 }
36614
36615
36616 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
36617   unsigned int jresult ;
36618   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36619   unsigned int result;
36620
36621   arg1 = (Dali::Actor *)jarg1;
36622   {
36623     try {
36624       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
36625     } catch (std::out_of_range& e) {
36626       {
36627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36628       };
36629     } catch (std::exception& e) {
36630       {
36631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36632       };
36633     } catch (Dali::DaliException e) {
36634       {
36635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36636       };
36637     } catch (...) {
36638       {
36639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36640       };
36641     }
36642   }
36643
36644   jresult = result;
36645   return jresult;
36646 }
36647
36648
36649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
36650   void * jresult ;
36651   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36652   unsigned int arg2 ;
36653   Dali::Renderer result;
36654
36655   arg1 = (Dali::Actor *)jarg1;
36656   arg2 = (unsigned int)jarg2;
36657   {
36658     try {
36659       result = (arg1)->GetRendererAt(arg2);
36660     } catch (std::out_of_range& e) {
36661       {
36662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36663       };
36664     } catch (std::exception& e) {
36665       {
36666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36667       };
36668     } catch (Dali::DaliException e) {
36669       {
36670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36671       };
36672     } catch (...) {
36673       {
36674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36675       };
36676     }
36677   }
36678
36679   jresult = new Dali::Renderer((const Dali::Renderer &)result);
36680   return jresult;
36681 }
36682
36683
36684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
36685   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36686   Dali::Renderer *arg2 = 0 ;
36687
36688   arg1 = (Dali::Actor *)jarg1;
36689   arg2 = (Dali::Renderer *)jarg2;
36690   if (!arg2) {
36691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36692     return ;
36693   }
36694   {
36695     try {
36696       (arg1)->RemoveRenderer(*arg2);
36697     } catch (std::out_of_range& e) {
36698       {
36699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36700       };
36701     } catch (std::exception& e) {
36702       {
36703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36704       };
36705     } catch (Dali::DaliException e) {
36706       {
36707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36708       };
36709     } catch (...) {
36710       {
36711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36712       };
36713     }
36714   }
36715
36716 }
36717
36718
36719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
36720   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36721   unsigned int arg2 ;
36722
36723   arg1 = (Dali::Actor *)jarg1;
36724   arg2 = (unsigned int)jarg2;
36725   {
36726     try {
36727       (arg1)->RemoveRenderer(arg2);
36728     } catch (std::out_of_range& e) {
36729       {
36730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36731       };
36732     } catch (std::exception& e) {
36733       {
36734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36735       };
36736     } catch (Dali::DaliException e) {
36737       {
36738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36739       };
36740     } catch (...) {
36741       {
36742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36743       };
36744     }
36745   }
36746
36747 }
36748
36749
36750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
36751   void * jresult ;
36752   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36753   Dali::Actor::TouchSignalType *result = 0 ;
36754
36755   arg1 = (Dali::Actor *)jarg1;
36756   {
36757     try {
36758       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
36759     } catch (std::out_of_range& e) {
36760       {
36761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36762       };
36763     } catch (std::exception& e) {
36764       {
36765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36766       };
36767     } catch (Dali::DaliException e) {
36768       {
36769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36770       };
36771     } catch (...) {
36772       {
36773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36774       };
36775     }
36776   }
36777
36778   jresult = (void *)result;
36779   return jresult;
36780 }
36781
36782
36783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
36784   void * jresult ;
36785   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36786   Dali::Actor::TouchDataSignalType *result = 0 ;
36787
36788   arg1 = (Dali::Actor *)jarg1;
36789   {
36790     try {
36791       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
36792     } catch (std::out_of_range& e) {
36793       {
36794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36795       };
36796     } catch (std::exception& e) {
36797       {
36798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36799       };
36800     } catch (Dali::DaliException e) {
36801       {
36802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36803       };
36804     } catch (...) {
36805       {
36806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36807       };
36808     }
36809   }
36810
36811   jresult = (void *)result;
36812   return jresult;
36813 }
36814
36815
36816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
36817   void * jresult ;
36818   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36819   Dali::Actor::HoverSignalType *result = 0 ;
36820
36821   arg1 = (Dali::Actor *)jarg1;
36822   {
36823     try {
36824       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
36825     } catch (std::out_of_range& e) {
36826       {
36827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36828       };
36829     } catch (std::exception& e) {
36830       {
36831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36832       };
36833     } catch (Dali::DaliException e) {
36834       {
36835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36836       };
36837     } catch (...) {
36838       {
36839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36840       };
36841     }
36842   }
36843
36844   jresult = (void *)result;
36845   return jresult;
36846 }
36847
36848
36849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
36850   void * jresult ;
36851   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36852   Dali::Actor::WheelEventSignalType *result = 0 ;
36853
36854   arg1 = (Dali::Actor *)jarg1;
36855   {
36856     try {
36857       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
36858     } catch (std::out_of_range& e) {
36859       {
36860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36861       };
36862     } catch (std::exception& e) {
36863       {
36864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36865       };
36866     } catch (Dali::DaliException e) {
36867       {
36868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36869       };
36870     } catch (...) {
36871       {
36872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36873       };
36874     }
36875   }
36876
36877   jresult = (void *)result;
36878   return jresult;
36879 }
36880
36881
36882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
36883   void * jresult ;
36884   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36885   Dali::Actor::OnStageSignalType *result = 0 ;
36886
36887   arg1 = (Dali::Actor *)jarg1;
36888   {
36889     try {
36890       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
36891     } catch (std::out_of_range& e) {
36892       {
36893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36894       };
36895     } catch (std::exception& e) {
36896       {
36897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36898       };
36899     } catch (Dali::DaliException e) {
36900       {
36901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36902       };
36903     } catch (...) {
36904       {
36905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36906       };
36907     }
36908   }
36909
36910   jresult = (void *)result;
36911   return jresult;
36912 }
36913
36914
36915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
36916   void * jresult ;
36917   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36918   Dali::Actor::OffStageSignalType *result = 0 ;
36919
36920   arg1 = (Dali::Actor *)jarg1;
36921   {
36922     try {
36923       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
36924     } catch (std::out_of_range& e) {
36925       {
36926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36927       };
36928     } catch (std::exception& e) {
36929       {
36930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36931       };
36932     } catch (Dali::DaliException e) {
36933       {
36934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36935       };
36936     } catch (...) {
36937       {
36938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36939       };
36940     }
36941   }
36942
36943   jresult = (void *)result;
36944   return jresult;
36945 }
36946
36947
36948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
36949   void * jresult ;
36950   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36951   Dali::Actor::OnRelayoutSignalType *result = 0 ;
36952
36953   arg1 = (Dali::Actor *)jarg1;
36954   {
36955     try {
36956       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
36957     } catch (std::out_of_range& e) {
36958       {
36959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36960       };
36961     } catch (std::exception& e) {
36962       {
36963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36964       };
36965     } catch (Dali::DaliException e) {
36966       {
36967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36968       };
36969     } catch (...) {
36970       {
36971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36972       };
36973     }
36974   }
36975
36976   jresult = (void *)result;
36977   return jresult;
36978 }
36979
36980
36981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
36982   Dali::Actor *arg1 = 0 ;
36983
36984   arg1 = (Dali::Actor *)jarg1;
36985   if (!arg1) {
36986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
36987     return ;
36988   }
36989   {
36990     try {
36991       Dali::UnparentAndReset(*arg1);
36992     } catch (std::out_of_range& e) {
36993       {
36994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36995       };
36996     } catch (std::exception& e) {
36997       {
36998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36999       };
37000     } catch (Dali::DaliException e) {
37001       {
37002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37003       };
37004     } catch (...) {
37005       {
37006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37007       };
37008     }
37009   }
37010
37011 }
37012
37013
37014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
37015   int jresult ;
37016   int result;
37017
37018   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
37019   jresult = (int)result;
37020   return jresult;
37021 }
37022
37023
37024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
37025   int jresult ;
37026   int result;
37027
37028   result = (int)Dali::Layer::Property::CLIPPING_BOX;
37029   jresult = (int)result;
37030   return jresult;
37031 }
37032
37033
37034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
37035   int jresult ;
37036   int result;
37037
37038   result = (int)Dali::Layer::Property::BEHAVIOR;
37039   jresult = (int)result;
37040   return jresult;
37041 }
37042
37043
37044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
37045   void * jresult ;
37046   Dali::Layer::Property *result = 0 ;
37047
37048   {
37049     try {
37050       result = (Dali::Layer::Property *)new Dali::Layer::Property();
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_delete_Layer_Property(void * jarg1) {
37076   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
37077
37078   arg1 = (Dali::Layer::Property *)jarg1;
37079   {
37080     try {
37081       delete arg1;
37082     } catch (std::out_of_range& e) {
37083       {
37084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37085       };
37086     } catch (std::exception& e) {
37087       {
37088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37089       };
37090     } catch (Dali::DaliException e) {
37091       {
37092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37093       };
37094     } catch (...) {
37095       {
37096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37097       };
37098     }
37099   }
37100
37101 }
37102
37103
37104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
37105   void * jresult ;
37106   Dali::Layer *result = 0 ;
37107
37108   {
37109     try {
37110       result = (Dali::Layer *)new Dali::Layer();
37111     } catch (std::out_of_range& e) {
37112       {
37113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37114       };
37115     } catch (std::exception& e) {
37116       {
37117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37118       };
37119     } catch (Dali::DaliException e) {
37120       {
37121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37122       };
37123     } catch (...) {
37124       {
37125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37126       };
37127     }
37128   }
37129
37130   jresult = (void *)result;
37131   return jresult;
37132 }
37133
37134
37135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37136   void * jresult ;
37137   Dali::Layer result;
37138
37139   {
37140     try {
37141       result = Dali::Layer::New();
37142     } catch (std::out_of_range& e) {
37143       {
37144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37145       };
37146     } catch (std::exception& e) {
37147       {
37148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37149       };
37150     } catch (Dali::DaliException e) {
37151       {
37152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37153       };
37154     } catch (...) {
37155       {
37156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37157       };
37158     }
37159   }
37160
37161   jresult = new Dali::Layer((const Dali::Layer &)result);
37162   return jresult;
37163 }
37164
37165
37166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
37167   void * jresult ;
37168   Dali::BaseHandle arg1 ;
37169   Dali::BaseHandle *argp1 ;
37170   Dali::Layer result;
37171
37172   argp1 = (Dali::BaseHandle *)jarg1;
37173   if (!argp1) {
37174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37175     return 0;
37176   }
37177   arg1 = *argp1;
37178   {
37179     try {
37180       result = Dali::Layer::DownCast(arg1);
37181     } catch (std::out_of_range& e) {
37182       {
37183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37184       };
37185     } catch (std::exception& e) {
37186       {
37187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37188       };
37189     } catch (Dali::DaliException e) {
37190       {
37191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37192       };
37193     } catch (...) {
37194       {
37195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37196       };
37197     }
37198   }
37199
37200   jresult = new Dali::Layer((const Dali::Layer &)result);
37201   return jresult;
37202 }
37203
37204
37205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
37206   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37207
37208   arg1 = (Dali::Layer *)jarg1;
37209   {
37210     try {
37211       delete arg1;
37212     } catch (std::out_of_range& e) {
37213       {
37214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37215       };
37216     } catch (std::exception& e) {
37217       {
37218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37219       };
37220     } catch (Dali::DaliException e) {
37221       {
37222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37223       };
37224     } catch (...) {
37225       {
37226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37227       };
37228     }
37229   }
37230
37231 }
37232
37233
37234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37235   void * jresult ;
37236   Dali::Layer *arg1 = 0 ;
37237   Dali::Layer *result = 0 ;
37238
37239   arg1 = (Dali::Layer *)jarg1;
37240   if (!arg1) {
37241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37242     return 0;
37243   }
37244   {
37245     try {
37246       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
37247     } catch (std::out_of_range& e) {
37248       {
37249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37250       };
37251     } catch (std::exception& e) {
37252       {
37253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37254       };
37255     } catch (Dali::DaliException e) {
37256       {
37257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37258       };
37259     } catch (...) {
37260       {
37261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37262       };
37263     }
37264   }
37265
37266   jresult = (void *)result;
37267   return jresult;
37268 }
37269
37270
37271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37272   void * jresult ;
37273   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37274   Dali::Layer *arg2 = 0 ;
37275   Dali::Layer *result = 0 ;
37276
37277   arg1 = (Dali::Layer *)jarg1;
37278   arg2 = (Dali::Layer *)jarg2;
37279   if (!arg2) {
37280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37281     return 0;
37282   }
37283   {
37284     try {
37285       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
37286     } catch (std::out_of_range& e) {
37287       {
37288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37289       };
37290     } catch (std::exception& e) {
37291       {
37292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37293       };
37294     } catch (Dali::DaliException e) {
37295       {
37296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37297       };
37298     } catch (...) {
37299       {
37300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37301       };
37302     }
37303   }
37304
37305   jresult = (void *)result;
37306   return jresult;
37307 }
37308
37309
37310 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37311   unsigned int jresult ;
37312   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37313   unsigned int result;
37314
37315   arg1 = (Dali::Layer *)jarg1;
37316   {
37317     try {
37318       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
37319     } catch (std::out_of_range& e) {
37320       {
37321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37322       };
37323     } catch (std::exception& e) {
37324       {
37325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37326       };
37327     } catch (Dali::DaliException e) {
37328       {
37329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37330       };
37331     } catch (...) {
37332       {
37333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37334       };
37335     }
37336   }
37337
37338   jresult = result;
37339   return jresult;
37340 }
37341
37342
37343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37344   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37345
37346   arg1 = (Dali::Layer *)jarg1;
37347   {
37348     try {
37349       (arg1)->Raise();
37350     } catch (std::out_of_range& e) {
37351       {
37352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37353       };
37354     } catch (std::exception& e) {
37355       {
37356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37357       };
37358     } catch (Dali::DaliException e) {
37359       {
37360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37361       };
37362     } catch (...) {
37363       {
37364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37365       };
37366     }
37367   }
37368
37369 }
37370
37371
37372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37373   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37374
37375   arg1 = (Dali::Layer *)jarg1;
37376   {
37377     try {
37378       (arg1)->Lower();
37379     } catch (std::out_of_range& e) {
37380       {
37381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37382       };
37383     } catch (std::exception& e) {
37384       {
37385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37386       };
37387     } catch (Dali::DaliException e) {
37388       {
37389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37390       };
37391     } catch (...) {
37392       {
37393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37394       };
37395     }
37396   }
37397
37398 }
37399
37400
37401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37402   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37403   Dali::Layer arg2 ;
37404   Dali::Layer *argp2 ;
37405
37406   arg1 = (Dali::Layer *)jarg1;
37407   argp2 = (Dali::Layer *)jarg2;
37408   if (!argp2) {
37409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37410     return ;
37411   }
37412   arg2 = *argp2;
37413   {
37414     try {
37415       (arg1)->RaiseAbove(arg2);
37416     } catch (std::out_of_range& e) {
37417       {
37418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37419       };
37420     } catch (std::exception& e) {
37421       {
37422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37423       };
37424     } catch (Dali::DaliException e) {
37425       {
37426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37427       };
37428     } catch (...) {
37429       {
37430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37431       };
37432     }
37433   }
37434
37435 }
37436
37437
37438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
37439   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37440   Dali::Layer arg2 ;
37441   Dali::Layer *argp2 ;
37442
37443   arg1 = (Dali::Layer *)jarg1;
37444   argp2 = (Dali::Layer *)jarg2;
37445   if (!argp2) {
37446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37447     return ;
37448   }
37449   arg2 = *argp2;
37450   {
37451     try {
37452       (arg1)->LowerBelow(arg2);
37453     } catch (std::out_of_range& e) {
37454       {
37455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37456       };
37457     } catch (std::exception& e) {
37458       {
37459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37460       };
37461     } catch (Dali::DaliException e) {
37462       {
37463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37464       };
37465     } catch (...) {
37466       {
37467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37468       };
37469     }
37470   }
37471
37472 }
37473
37474
37475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
37476   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37477
37478   arg1 = (Dali::Layer *)jarg1;
37479   {
37480     try {
37481       (arg1)->RaiseToTop();
37482     } catch (std::out_of_range& e) {
37483       {
37484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37485       };
37486     } catch (std::exception& e) {
37487       {
37488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37489       };
37490     } catch (Dali::DaliException e) {
37491       {
37492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37493       };
37494     } catch (...) {
37495       {
37496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37497       };
37498     }
37499   }
37500
37501 }
37502
37503
37504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
37505   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37506
37507   arg1 = (Dali::Layer *)jarg1;
37508   {
37509     try {
37510       (arg1)->LowerToBottom();
37511     } catch (std::out_of_range& e) {
37512       {
37513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37514       };
37515     } catch (std::exception& e) {
37516       {
37517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37518       };
37519     } catch (Dali::DaliException e) {
37520       {
37521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37522       };
37523     } catch (...) {
37524       {
37525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37526       };
37527     }
37528   }
37529
37530 }
37531
37532
37533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37534   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37535   Dali::Layer arg2 ;
37536   Dali::Layer *argp2 ;
37537
37538   arg1 = (Dali::Layer *)jarg1;
37539   argp2 = (Dali::Layer *)jarg2;
37540   if (!argp2) {
37541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37542     return ;
37543   }
37544   arg2 = *argp2;
37545   {
37546     try {
37547       (arg1)->MoveAbove(arg2);
37548     } catch (std::out_of_range& e) {
37549       {
37550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37551       };
37552     } catch (std::exception& e) {
37553       {
37554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37555       };
37556     } catch (Dali::DaliException e) {
37557       {
37558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37559       };
37560     } catch (...) {
37561       {
37562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37563       };
37564     }
37565   }
37566
37567 }
37568
37569
37570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
37571   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37572   Dali::Layer arg2 ;
37573   Dali::Layer *argp2 ;
37574
37575   arg1 = (Dali::Layer *)jarg1;
37576   argp2 = (Dali::Layer *)jarg2;
37577   if (!argp2) {
37578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37579     return ;
37580   }
37581   arg2 = *argp2;
37582   {
37583     try {
37584       (arg1)->MoveBelow(arg2);
37585     } catch (std::out_of_range& e) {
37586       {
37587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37588       };
37589     } catch (std::exception& e) {
37590       {
37591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37592       };
37593     } catch (Dali::DaliException e) {
37594       {
37595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37596       };
37597     } catch (...) {
37598       {
37599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37600       };
37601     }
37602   }
37603
37604 }
37605
37606
37607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
37608   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37609   Dali::Layer::Behavior arg2 ;
37610
37611   arg1 = (Dali::Layer *)jarg1;
37612   arg2 = (Dali::Layer::Behavior)jarg2;
37613   {
37614     try {
37615       (arg1)->SetBehavior(arg2);
37616     } catch (std::out_of_range& e) {
37617       {
37618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37619       };
37620     } catch (std::exception& e) {
37621       {
37622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37623       };
37624     } catch (Dali::DaliException e) {
37625       {
37626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37627       };
37628     } catch (...) {
37629       {
37630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37631       };
37632     }
37633   }
37634
37635 }
37636
37637
37638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
37639   int jresult ;
37640   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37641   Dali::Layer::Behavior result;
37642
37643   arg1 = (Dali::Layer *)jarg1;
37644   {
37645     try {
37646       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
37647     } catch (std::out_of_range& e) {
37648       {
37649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37650       };
37651     } catch (std::exception& e) {
37652       {
37653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37654       };
37655     } catch (Dali::DaliException e) {
37656       {
37657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37658       };
37659     } catch (...) {
37660       {
37661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37662       };
37663     }
37664   }
37665
37666   jresult = (int)result;
37667   return jresult;
37668 }
37669
37670
37671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
37672   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37673   bool arg2 ;
37674
37675   arg1 = (Dali::Layer *)jarg1;
37676   arg2 = jarg2 ? true : false;
37677   {
37678     try {
37679       (arg1)->SetClipping(arg2);
37680     } catch (std::out_of_range& e) {
37681       {
37682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37683       };
37684     } catch (std::exception& e) {
37685       {
37686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37687       };
37688     } catch (Dali::DaliException e) {
37689       {
37690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37691       };
37692     } catch (...) {
37693       {
37694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37695       };
37696     }
37697   }
37698
37699 }
37700
37701
37702 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
37703   unsigned int jresult ;
37704   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37705   bool result;
37706
37707   arg1 = (Dali::Layer *)jarg1;
37708   {
37709     try {
37710       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
37711     } catch (std::out_of_range& e) {
37712       {
37713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37714       };
37715     } catch (std::exception& e) {
37716       {
37717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37718       };
37719     } catch (Dali::DaliException e) {
37720       {
37721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37722       };
37723     } catch (...) {
37724       {
37725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37726       };
37727     }
37728   }
37729
37730   jresult = result;
37731   return jresult;
37732 }
37733
37734
37735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
37736   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37737   int arg2 ;
37738   int arg3 ;
37739   int arg4 ;
37740   int arg5 ;
37741
37742   arg1 = (Dali::Layer *)jarg1;
37743   arg2 = (int)jarg2;
37744   arg3 = (int)jarg3;
37745   arg4 = (int)jarg4;
37746   arg5 = (int)jarg5;
37747   {
37748     try {
37749       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
37750     } catch (std::out_of_range& e) {
37751       {
37752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37753       };
37754     } catch (std::exception& e) {
37755       {
37756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37757       };
37758     } catch (Dali::DaliException e) {
37759       {
37760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37761       };
37762     } catch (...) {
37763       {
37764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37765       };
37766     }
37767   }
37768
37769 }
37770
37771
37772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
37773   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37774   Dali::ClippingBox arg2 ;
37775   Dali::ClippingBox *argp2 ;
37776
37777   arg1 = (Dali::Layer *)jarg1;
37778   argp2 = (Dali::ClippingBox *)jarg2;
37779   if (!argp2) {
37780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
37781     return ;
37782   }
37783   arg2 = *argp2;
37784   {
37785     try {
37786       (arg1)->SetClippingBox(arg2);
37787     } catch (std::out_of_range& e) {
37788       {
37789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37790       };
37791     } catch (std::exception& e) {
37792       {
37793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37794       };
37795     } catch (Dali::DaliException e) {
37796       {
37797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37798       };
37799     } catch (...) {
37800       {
37801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37802       };
37803     }
37804   }
37805
37806 }
37807
37808
37809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
37810   void * jresult ;
37811   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37812   Dali::ClippingBox result;
37813
37814   arg1 = (Dali::Layer *)jarg1;
37815   {
37816     try {
37817       result = ((Dali::Layer const *)arg1)->GetClippingBox();
37818     } catch (std::out_of_range& e) {
37819       {
37820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37821       };
37822     } catch (std::exception& e) {
37823       {
37824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37825       };
37826     } catch (Dali::DaliException e) {
37827       {
37828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37829       };
37830     } catch (...) {
37831       {
37832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37833       };
37834     }
37835   }
37836
37837   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
37838   return jresult;
37839 }
37840
37841
37842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
37843   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37844   bool arg2 ;
37845
37846   arg1 = (Dali::Layer *)jarg1;
37847   arg2 = jarg2 ? true : false;
37848   {
37849     try {
37850       (arg1)->SetDepthTestDisabled(arg2);
37851     } catch (std::out_of_range& e) {
37852       {
37853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37854       };
37855     } catch (std::exception& e) {
37856       {
37857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37858       };
37859     } catch (Dali::DaliException e) {
37860       {
37861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37862       };
37863     } catch (...) {
37864       {
37865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37866       };
37867     }
37868   }
37869
37870 }
37871
37872
37873 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
37874   unsigned int jresult ;
37875   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37876   bool result;
37877
37878   arg1 = (Dali::Layer *)jarg1;
37879   {
37880     try {
37881       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
37882     } catch (std::out_of_range& e) {
37883       {
37884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37885       };
37886     } catch (std::exception& e) {
37887       {
37888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37889       };
37890     } catch (Dali::DaliException e) {
37891       {
37892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37893       };
37894     } catch (...) {
37895       {
37896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37897       };
37898     }
37899   }
37900
37901   jresult = result;
37902   return jresult;
37903 }
37904
37905
37906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
37907   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37908   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
37909
37910   arg1 = (Dali::Layer *)jarg1;
37911   arg2 = (Dali::Layer::SortFunctionType)jarg2;
37912   {
37913     try {
37914       (arg1)->SetSortFunction(arg2);
37915     } catch (std::out_of_range& e) {
37916       {
37917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37918       };
37919     } catch (std::exception& e) {
37920       {
37921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37922       };
37923     } catch (Dali::DaliException e) {
37924       {
37925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37926       };
37927     } catch (...) {
37928       {
37929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37930       };
37931     }
37932   }
37933
37934 }
37935
37936
37937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
37938   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37939   bool arg2 ;
37940
37941   arg1 = (Dali::Layer *)jarg1;
37942   arg2 = jarg2 ? true : false;
37943   {
37944     try {
37945       (arg1)->SetTouchConsumed(arg2);
37946     } catch (std::out_of_range& e) {
37947       {
37948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37949       };
37950     } catch (std::exception& e) {
37951       {
37952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37953       };
37954     } catch (Dali::DaliException e) {
37955       {
37956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37957       };
37958     } catch (...) {
37959       {
37960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37961       };
37962     }
37963   }
37964
37965 }
37966
37967
37968 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
37969   unsigned int jresult ;
37970   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37971   bool result;
37972
37973   arg1 = (Dali::Layer *)jarg1;
37974   {
37975     try {
37976       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
37977     } catch (std::out_of_range& e) {
37978       {
37979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37980       };
37981     } catch (std::exception& e) {
37982       {
37983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37984       };
37985     } catch (Dali::DaliException e) {
37986       {
37987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37988       };
37989     } catch (...) {
37990       {
37991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37992       };
37993     }
37994   }
37995
37996   jresult = result;
37997   return jresult;
37998 }
37999
38000
38001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
38002   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38003   bool arg2 ;
38004
38005   arg1 = (Dali::Layer *)jarg1;
38006   arg2 = jarg2 ? true : false;
38007   {
38008     try {
38009       (arg1)->SetHoverConsumed(arg2);
38010     } catch (std::out_of_range& e) {
38011       {
38012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38013       };
38014     } catch (std::exception& e) {
38015       {
38016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38017       };
38018     } catch (Dali::DaliException e) {
38019       {
38020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38021       };
38022     } catch (...) {
38023       {
38024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38025       };
38026     }
38027   }
38028
38029 }
38030
38031
38032 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
38033   unsigned int jresult ;
38034   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38035   bool result;
38036
38037   arg1 = (Dali::Layer *)jarg1;
38038   {
38039     try {
38040       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
38041     } catch (std::out_of_range& e) {
38042       {
38043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38044       };
38045     } catch (std::exception& e) {
38046       {
38047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38048       };
38049     } catch (Dali::DaliException e) {
38050       {
38051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38052       };
38053     } catch (...) {
38054       {
38055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38056       };
38057     }
38058   }
38059
38060   jresult = result;
38061   return jresult;
38062 }
38063
38064
38065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
38066   void * jresult ;
38067   Dali::Vector4 *result = 0 ;
38068
38069   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
38070   jresult = (void *)result;
38071   return jresult;
38072 }
38073
38074
38075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
38076   void * jresult ;
38077   Dali::Vector4 *result = 0 ;
38078
38079   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
38080   jresult = (void *)result;
38081   return jresult;
38082 }
38083
38084
38085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
38086   void * jresult ;
38087   Dali::Stage *result = 0 ;
38088
38089   {
38090     try {
38091       result = (Dali::Stage *)new Dali::Stage();
38092     } catch (std::out_of_range& e) {
38093       {
38094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38095       };
38096     } catch (std::exception& e) {
38097       {
38098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38099       };
38100     } catch (Dali::DaliException e) {
38101       {
38102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38103       };
38104     } catch (...) {
38105       {
38106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38107       };
38108     }
38109   }
38110
38111   jresult = (void *)result;
38112   return jresult;
38113 }
38114
38115
38116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
38117   void * jresult ;
38118   Dali::Stage result;
38119
38120   {
38121     try {
38122       result = Dali::Stage::GetCurrent();
38123     } catch (std::out_of_range& e) {
38124       {
38125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38126       };
38127     } catch (std::exception& e) {
38128       {
38129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38130       };
38131     } catch (Dali::DaliException e) {
38132       {
38133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38134       };
38135     } catch (...) {
38136       {
38137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38138       };
38139     }
38140   }
38141
38142   jresult = new Dali::Stage((const Dali::Stage &)result);
38143   return jresult;
38144 }
38145
38146
38147 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
38148   unsigned int jresult ;
38149   bool result;
38150
38151   {
38152     try {
38153       result = (bool)Dali::Stage::IsInstalled();
38154     } catch (std::out_of_range& e) {
38155       {
38156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38157       };
38158     } catch (std::exception& e) {
38159       {
38160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38161       };
38162     } catch (Dali::DaliException e) {
38163       {
38164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38165       };
38166     } catch (...) {
38167       {
38168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38169       };
38170     }
38171   }
38172
38173   jresult = result;
38174   return jresult;
38175 }
38176
38177
38178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
38179   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38180
38181   arg1 = (Dali::Stage *)jarg1;
38182   {
38183     try {
38184       delete arg1;
38185     } catch (std::out_of_range& e) {
38186       {
38187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38188       };
38189     } catch (std::exception& e) {
38190       {
38191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38192       };
38193     } catch (Dali::DaliException e) {
38194       {
38195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38196       };
38197     } catch (...) {
38198       {
38199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38200       };
38201     }
38202   }
38203
38204 }
38205
38206
38207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
38208   void * jresult ;
38209   Dali::Stage *arg1 = 0 ;
38210   Dali::Stage *result = 0 ;
38211
38212   arg1 = (Dali::Stage *)jarg1;
38213   if (!arg1) {
38214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38215     return 0;
38216   }
38217   {
38218     try {
38219       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
38220     } catch (std::out_of_range& e) {
38221       {
38222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38223       };
38224     } catch (std::exception& e) {
38225       {
38226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38227       };
38228     } catch (Dali::DaliException e) {
38229       {
38230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38231       };
38232     } catch (...) {
38233       {
38234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38235       };
38236     }
38237   }
38238
38239   jresult = (void *)result;
38240   return jresult;
38241 }
38242
38243
38244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
38245   void * jresult ;
38246   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38247   Dali::Stage *arg2 = 0 ;
38248   Dali::Stage *result = 0 ;
38249
38250   arg1 = (Dali::Stage *)jarg1;
38251   arg2 = (Dali::Stage *)jarg2;
38252   if (!arg2) {
38253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38254     return 0;
38255   }
38256   {
38257     try {
38258       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
38259     } catch (std::out_of_range& e) {
38260       {
38261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38262       };
38263     } catch (std::exception& e) {
38264       {
38265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38266       };
38267     } catch (Dali::DaliException e) {
38268       {
38269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38270       };
38271     } catch (...) {
38272       {
38273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38274       };
38275     }
38276   }
38277
38278   jresult = (void *)result;
38279   return jresult;
38280 }
38281
38282
38283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
38284   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38285   Dali::Actor *arg2 = 0 ;
38286
38287   arg1 = (Dali::Stage *)jarg1;
38288   arg2 = (Dali::Actor *)jarg2;
38289   if (!arg2) {
38290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38291     return ;
38292   }
38293   {
38294     try {
38295       (arg1)->Add(*arg2);
38296     } catch (std::out_of_range& e) {
38297       {
38298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38299       };
38300     } catch (std::exception& e) {
38301       {
38302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38303       };
38304     } catch (Dali::DaliException e) {
38305       {
38306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38307       };
38308     } catch (...) {
38309       {
38310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38311       };
38312     }
38313   }
38314
38315 }
38316
38317
38318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
38319   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38320   Dali::Actor *arg2 = 0 ;
38321
38322   arg1 = (Dali::Stage *)jarg1;
38323   arg2 = (Dali::Actor *)jarg2;
38324   if (!arg2) {
38325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38326     return ;
38327   }
38328   {
38329     try {
38330       (arg1)->Remove(*arg2);
38331     } catch (std::out_of_range& e) {
38332       {
38333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38334       };
38335     } catch (std::exception& e) {
38336       {
38337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38338       };
38339     } catch (Dali::DaliException e) {
38340       {
38341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38342       };
38343     } catch (...) {
38344       {
38345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38346       };
38347     }
38348   }
38349
38350 }
38351
38352
38353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
38354   void * jresult ;
38355   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38356   Dali::Vector2 result;
38357
38358   arg1 = (Dali::Stage *)jarg1;
38359   {
38360     try {
38361       result = ((Dali::Stage const *)arg1)->GetSize();
38362     } catch (std::out_of_range& e) {
38363       {
38364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38365       };
38366     } catch (std::exception& e) {
38367       {
38368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38369       };
38370     } catch (Dali::DaliException e) {
38371       {
38372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38373       };
38374     } catch (...) {
38375       {
38376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38377       };
38378     }
38379   }
38380
38381   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38382   return jresult;
38383 }
38384
38385
38386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
38387   void * jresult ;
38388   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38389   Dali::RenderTaskList result;
38390
38391   arg1 = (Dali::Stage *)jarg1;
38392   {
38393     try {
38394       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
38395     } catch (std::out_of_range& e) {
38396       {
38397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38398       };
38399     } catch (std::exception& e) {
38400       {
38401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38402       };
38403     } catch (Dali::DaliException e) {
38404       {
38405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38406       };
38407     } catch (...) {
38408       {
38409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38410       };
38411     }
38412   }
38413
38414   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
38415   return jresult;
38416 }
38417
38418
38419 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
38420   unsigned int jresult ;
38421   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38422   unsigned int result;
38423
38424   arg1 = (Dali::Stage *)jarg1;
38425   {
38426     try {
38427       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
38428     } catch (std::out_of_range& e) {
38429       {
38430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38431       };
38432     } catch (std::exception& e) {
38433       {
38434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38435       };
38436     } catch (Dali::DaliException e) {
38437       {
38438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38439       };
38440     } catch (...) {
38441       {
38442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38443       };
38444     }
38445   }
38446
38447   jresult = result;
38448   return jresult;
38449 }
38450
38451
38452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
38453   void * jresult ;
38454   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38455   unsigned int arg2 ;
38456   Dali::Layer result;
38457
38458   arg1 = (Dali::Stage *)jarg1;
38459   arg2 = (unsigned int)jarg2;
38460   {
38461     try {
38462       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
38463     } catch (std::out_of_range& e) {
38464       {
38465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38466       };
38467     } catch (std::exception& e) {
38468       {
38469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38470       };
38471     } catch (Dali::DaliException e) {
38472       {
38473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38474       };
38475     } catch (...) {
38476       {
38477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38478       };
38479     }
38480   }
38481
38482   jresult = new Dali::Layer((const Dali::Layer &)result);
38483   return jresult;
38484 }
38485
38486
38487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
38488   void * jresult ;
38489   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38490   Dali::Layer result;
38491
38492   arg1 = (Dali::Stage *)jarg1;
38493   {
38494     try {
38495       result = ((Dali::Stage const *)arg1)->GetRootLayer();
38496     } catch (std::out_of_range& e) {
38497       {
38498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38499       };
38500     } catch (std::exception& e) {
38501       {
38502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38503       };
38504     } catch (Dali::DaliException e) {
38505       {
38506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38507       };
38508     } catch (...) {
38509       {
38510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38511       };
38512     }
38513   }
38514
38515   jresult = new Dali::Layer((const Dali::Layer &)result);
38516   return jresult;
38517 }
38518
38519
38520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
38521   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38522   Dali::Vector4 arg2 ;
38523   Dali::Vector4 *argp2 ;
38524
38525   arg1 = (Dali::Stage *)jarg1;
38526   argp2 = (Dali::Vector4 *)jarg2;
38527   if (!argp2) {
38528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
38529     return ;
38530   }
38531   arg2 = *argp2;
38532   {
38533     try {
38534       (arg1)->SetBackgroundColor(arg2);
38535     } catch (std::out_of_range& e) {
38536       {
38537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38538       };
38539     } catch (std::exception& e) {
38540       {
38541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38542       };
38543     } catch (Dali::DaliException e) {
38544       {
38545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38546       };
38547     } catch (...) {
38548       {
38549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38550       };
38551     }
38552   }
38553
38554 }
38555
38556
38557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
38558   void * jresult ;
38559   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38560   Dali::Vector4 result;
38561
38562   arg1 = (Dali::Stage *)jarg1;
38563   {
38564     try {
38565       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
38566     } catch (std::out_of_range& e) {
38567       {
38568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38569       };
38570     } catch (std::exception& e) {
38571       {
38572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38573       };
38574     } catch (Dali::DaliException e) {
38575       {
38576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38577       };
38578     } catch (...) {
38579       {
38580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38581       };
38582     }
38583   }
38584
38585   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
38586   return jresult;
38587 }
38588
38589
38590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
38591   void * jresult ;
38592   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38593   Dali::Vector2 result;
38594
38595   arg1 = (Dali::Stage *)jarg1;
38596   {
38597     try {
38598       result = ((Dali::Stage const *)arg1)->GetDpi();
38599     } catch (std::out_of_range& e) {
38600       {
38601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38602       };
38603     } catch (std::exception& e) {
38604       {
38605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38606       };
38607     } catch (Dali::DaliException e) {
38608       {
38609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38610       };
38611     } catch (...) {
38612       {
38613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38614       };
38615     }
38616   }
38617
38618   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38619   return jresult;
38620 }
38621
38622
38623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
38624   void * jresult ;
38625   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38626   Dali::ObjectRegistry result;
38627
38628   arg1 = (Dali::Stage *)jarg1;
38629   {
38630     try {
38631       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
38632     } catch (std::out_of_range& e) {
38633       {
38634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38635       };
38636     } catch (std::exception& e) {
38637       {
38638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38639       };
38640     } catch (Dali::DaliException e) {
38641       {
38642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38643       };
38644     } catch (...) {
38645       {
38646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38647       };
38648     }
38649   }
38650
38651   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
38652   return jresult;
38653 }
38654
38655
38656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38657   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38658   float arg2 ;
38659
38660   arg1 = (Dali::Stage *)jarg1;
38661   arg2 = (float)jarg2;
38662   {
38663     try {
38664       (arg1)->KeepRendering(arg2);
38665     } catch (std::out_of_range& e) {
38666       {
38667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38668       };
38669     } catch (std::exception& e) {
38670       {
38671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38672       };
38673     } catch (Dali::DaliException e) {
38674       {
38675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38676       };
38677     } catch (...) {
38678       {
38679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38680       };
38681     }
38682   }
38683
38684 }
38685
38686
38687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38688   void * jresult ;
38689   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38690   Dali::Stage::KeyEventSignalType *result = 0 ;
38691
38692   arg1 = (Dali::Stage *)jarg1;
38693   {
38694     try {
38695       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38696     } catch (std::out_of_range& e) {
38697       {
38698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38699       };
38700     } catch (std::exception& e) {
38701       {
38702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38703       };
38704     } catch (Dali::DaliException e) {
38705       {
38706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38707       };
38708     } catch (...) {
38709       {
38710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38711       };
38712     }
38713   }
38714
38715   jresult = (void *)result;
38716   return jresult;
38717 }
38718
38719
38720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
38721   void * jresult ;
38722   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38723   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
38724
38725   arg1 = (Dali::Stage *)jarg1;
38726   {
38727     try {
38728       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
38729     } catch (std::out_of_range& e) {
38730       {
38731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38732       };
38733     } catch (std::exception& e) {
38734       {
38735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38736       };
38737     } catch (Dali::DaliException e) {
38738       {
38739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38740       };
38741     } catch (...) {
38742       {
38743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38744       };
38745     }
38746   }
38747
38748   jresult = (void *)result;
38749   return jresult;
38750 }
38751
38752
38753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
38754   void * jresult ;
38755   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38756   Dali::Stage::TouchSignalType *result = 0 ;
38757
38758   arg1 = (Dali::Stage *)jarg1;
38759   {
38760     try {
38761       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
38762     } catch (std::out_of_range& e) {
38763       {
38764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38765       };
38766     } catch (std::exception& e) {
38767       {
38768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38769       };
38770     } catch (Dali::DaliException e) {
38771       {
38772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38773       };
38774     } catch (...) {
38775       {
38776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38777       };
38778     }
38779   }
38780
38781   jresult = (void *)result;
38782   return jresult;
38783 }
38784
38785
38786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
38787   void * jresult ;
38788   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38789   Dali::Stage::WheelEventSignalType *result = 0 ;
38790
38791   arg1 = (Dali::Stage *)jarg1;
38792   {
38793     try {
38794       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
38795     } catch (std::out_of_range& e) {
38796       {
38797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38798       };
38799     } catch (std::exception& e) {
38800       {
38801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38802       };
38803     } catch (Dali::DaliException e) {
38804       {
38805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38806       };
38807     } catch (...) {
38808       {
38809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38810       };
38811     }
38812   }
38813
38814   jresult = (void *)result;
38815   return jresult;
38816 }
38817
38818
38819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
38820   void * jresult ;
38821   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38822   Dali::Stage::ContextStatusSignal *result = 0 ;
38823
38824   arg1 = (Dali::Stage *)jarg1;
38825   {
38826     try {
38827       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
38828     } catch (std::out_of_range& e) {
38829       {
38830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38831       };
38832     } catch (std::exception& e) {
38833       {
38834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38835       };
38836     } catch (Dali::DaliException e) {
38837       {
38838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38839       };
38840     } catch (...) {
38841       {
38842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38843       };
38844     }
38845   }
38846
38847   jresult = (void *)result;
38848   return jresult;
38849 }
38850
38851
38852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
38853   void * jresult ;
38854   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38855   Dali::Stage::ContextStatusSignal *result = 0 ;
38856
38857   arg1 = (Dali::Stage *)jarg1;
38858   {
38859     try {
38860       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
38861     } catch (std::out_of_range& e) {
38862       {
38863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38864       };
38865     } catch (std::exception& e) {
38866       {
38867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38868       };
38869     } catch (Dali::DaliException e) {
38870       {
38871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38872       };
38873     } catch (...) {
38874       {
38875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38876       };
38877     }
38878   }
38879
38880   jresult = (void *)result;
38881   return jresult;
38882 }
38883
38884
38885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
38886   void * jresult ;
38887   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38888   Dali::Stage::SceneCreatedSignalType *result = 0 ;
38889
38890   arg1 = (Dali::Stage *)jarg1;
38891   {
38892     try {
38893       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
38894     } catch (std::out_of_range& e) {
38895       {
38896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38897       };
38898     } catch (std::exception& e) {
38899       {
38900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38901       };
38902     } catch (Dali::DaliException e) {
38903       {
38904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38905       };
38906     } catch (...) {
38907       {
38908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38909       };
38910     }
38911   }
38912
38913   jresult = (void *)result;
38914   return jresult;
38915 }
38916
38917
38918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
38919   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
38920
38921   arg1 = (Dali::RelayoutContainer *)jarg1;
38922   {
38923     try {
38924       delete arg1;
38925     } catch (std::out_of_range& e) {
38926       {
38927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38928       };
38929     } catch (std::exception& e) {
38930       {
38931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38932       };
38933     } catch (Dali::DaliException e) {
38934       {
38935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38936       };
38937     } catch (...) {
38938       {
38939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38940       };
38941     }
38942   }
38943
38944 }
38945
38946
38947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
38948   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
38949   Dali::Actor *arg2 = 0 ;
38950   Dali::Vector2 *arg3 = 0 ;
38951
38952   arg1 = (Dali::RelayoutContainer *)jarg1;
38953   arg2 = (Dali::Actor *)jarg2;
38954   if (!arg2) {
38955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
38956     return ;
38957   }
38958   arg3 = (Dali::Vector2 *)jarg3;
38959   if (!arg3) {
38960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38961     return ;
38962   }
38963   {
38964     try {
38965       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
38966     } catch (std::out_of_range& e) {
38967       {
38968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38969       };
38970     } catch (std::exception& e) {
38971       {
38972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38973       };
38974     } catch (Dali::DaliException e) {
38975       {
38976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38977       };
38978     } catch (...) {
38979       {
38980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38981       };
38982     }
38983   }
38984
38985 }
38986
38987
38988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
38989   void * jresult ;
38990   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38991   Dali::CustomActor result;
38992
38993   arg1 = (Dali::CustomActorImpl *)jarg1;
38994   {
38995     try {
38996       result = ((Dali::CustomActorImpl const *)arg1)->Self();
38997     } catch (std::out_of_range& e) {
38998       {
38999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39000       };
39001     } catch (std::exception& e) {
39002       {
39003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39004       };
39005     } catch (Dali::DaliException e) {
39006       {
39007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39008       };
39009     } catch (...) {
39010       {
39011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39012       };
39013     }
39014   }
39015
39016   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39017   return jresult;
39018 }
39019
39020
39021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
39022   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39023   int arg2 ;
39024
39025   arg1 = (Dali::CustomActorImpl *)jarg1;
39026   arg2 = (int)jarg2;
39027   {
39028     try {
39029       (arg1)->OnStageConnection(arg2);
39030     } catch (std::out_of_range& e) {
39031       {
39032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39033       };
39034     } catch (std::exception& e) {
39035       {
39036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39037       };
39038     } catch (Dali::DaliException e) {
39039       {
39040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39041       };
39042     } catch (...) {
39043       {
39044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39045       };
39046     }
39047   }
39048
39049 }
39050
39051
39052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
39053   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39054
39055   arg1 = (Dali::CustomActorImpl *)jarg1;
39056   {
39057     try {
39058       (arg1)->OnStageDisconnection();
39059     } catch (std::out_of_range& e) {
39060       {
39061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39062       };
39063     } catch (std::exception& e) {
39064       {
39065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39066       };
39067     } catch (Dali::DaliException e) {
39068       {
39069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39070       };
39071     } catch (...) {
39072       {
39073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39074       };
39075     }
39076   }
39077
39078 }
39079
39080
39081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
39082   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39083   Dali::Actor *arg2 = 0 ;
39084
39085   arg1 = (Dali::CustomActorImpl *)jarg1;
39086   arg2 = (Dali::Actor *)jarg2;
39087   if (!arg2) {
39088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39089     return ;
39090   }
39091   {
39092     try {
39093       (arg1)->OnChildAdd(*arg2);
39094     } catch (std::out_of_range& e) {
39095       {
39096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39097       };
39098     } catch (std::exception& e) {
39099       {
39100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39101       };
39102     } catch (Dali::DaliException e) {
39103       {
39104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39105       };
39106     } catch (...) {
39107       {
39108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39109       };
39110     }
39111   }
39112
39113 }
39114
39115
39116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
39117   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39118   Dali::Actor *arg2 = 0 ;
39119
39120   arg1 = (Dali::CustomActorImpl *)jarg1;
39121   arg2 = (Dali::Actor *)jarg2;
39122   if (!arg2) {
39123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39124     return ;
39125   }
39126   {
39127     try {
39128       (arg1)->OnChildRemove(*arg2);
39129     } catch (std::out_of_range& e) {
39130       {
39131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39132       };
39133     } catch (std::exception& e) {
39134       {
39135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39136       };
39137     } catch (Dali::DaliException e) {
39138       {
39139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39140       };
39141     } catch (...) {
39142       {
39143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39144       };
39145     }
39146   }
39147
39148 }
39149
39150
39151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
39152   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39153   Dali::Property::Index arg2 ;
39154   Dali::Property::Value arg3 ;
39155   Dali::Property::Value *argp3 ;
39156
39157   arg1 = (Dali::CustomActorImpl *)jarg1;
39158   arg2 = (Dali::Property::Index)jarg2;
39159   argp3 = (Dali::Property::Value *)jarg3;
39160   if (!argp3) {
39161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39162     return ;
39163   }
39164   arg3 = *argp3;
39165   {
39166     try {
39167       (arg1)->OnPropertySet(arg2,arg3);
39168     } catch (std::out_of_range& e) {
39169       {
39170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39171       };
39172     } catch (std::exception& e) {
39173       {
39174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39175       };
39176     } catch (Dali::DaliException e) {
39177       {
39178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39179       };
39180     } catch (...) {
39181       {
39182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39183       };
39184     }
39185   }
39186
39187 }
39188
39189
39190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
39191   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39192   Dali::Vector3 *arg2 = 0 ;
39193
39194   arg1 = (Dali::CustomActorImpl *)jarg1;
39195   arg2 = (Dali::Vector3 *)jarg2;
39196   if (!arg2) {
39197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39198     return ;
39199   }
39200   {
39201     try {
39202       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
39203     } catch (std::out_of_range& e) {
39204       {
39205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39206       };
39207     } catch (std::exception& e) {
39208       {
39209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39210       };
39211     } catch (Dali::DaliException e) {
39212       {
39213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39214       };
39215     } catch (...) {
39216       {
39217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39218       };
39219     }
39220   }
39221
39222 }
39223
39224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
39225   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39226   Dali::Animation *arg2 = 0 ;
39227   Dali::Vector3 *arg3 = 0 ;
39228
39229   arg1 = (Dali::CustomActorImpl *)jarg1;
39230   arg2 = (Dali::Animation *)jarg2;
39231   if (!arg2) {
39232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
39233     return ;
39234   }
39235   arg3 = (Dali::Vector3 *)jarg3;
39236   if (!arg3) {
39237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39238     return ;
39239   }
39240   {
39241     try {
39242       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
39243     } catch (std::out_of_range& e) {
39244       {
39245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39246       };
39247     } catch (std::exception& e) {
39248       {
39249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39250       };
39251     } catch (Dali::DaliException e) {
39252       {
39253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39254       };
39255     } catch (...) {
39256       {
39257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39258       };
39259     }
39260   }
39261
39262 }
39263
39264
39265 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
39266   unsigned int jresult ;
39267   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39268   Dali::TouchEvent *arg2 = 0 ;
39269   bool result;
39270
39271   arg1 = (Dali::CustomActorImpl *)jarg1;
39272   arg2 = (Dali::TouchEvent *)jarg2;
39273   if (!arg2) {
39274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
39275     return 0;
39276   }
39277   {
39278     try {
39279       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
39280     } catch (std::out_of_range& e) {
39281       {
39282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39283       };
39284     } catch (std::exception& e) {
39285       {
39286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39287       };
39288     } catch (Dali::DaliException e) {
39289       {
39290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39291       };
39292     } catch (...) {
39293       {
39294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39295       };
39296     }
39297   }
39298
39299   jresult = result;
39300   return jresult;
39301 }
39302
39303
39304 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
39305   unsigned int jresult ;
39306   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39307   Dali::HoverEvent *arg2 = 0 ;
39308   bool result;
39309
39310   arg1 = (Dali::CustomActorImpl *)jarg1;
39311   arg2 = (Dali::HoverEvent *)jarg2;
39312   if (!arg2) {
39313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
39314     return 0;
39315   }
39316   {
39317     try {
39318       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
39319     } catch (std::out_of_range& e) {
39320       {
39321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39322       };
39323     } catch (std::exception& e) {
39324       {
39325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39326       };
39327     } catch (Dali::DaliException e) {
39328       {
39329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39330       };
39331     } catch (...) {
39332       {
39333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39334       };
39335     }
39336   }
39337
39338   jresult = result;
39339   return jresult;
39340 }
39341
39342
39343 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
39344   unsigned int jresult ;
39345   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39346   Dali::KeyEvent *arg2 = 0 ;
39347   bool result;
39348
39349   arg1 = (Dali::CustomActorImpl *)jarg1;
39350   arg2 = (Dali::KeyEvent *)jarg2;
39351   if (!arg2) {
39352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
39353     return 0;
39354   }
39355   {
39356     try {
39357       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
39358     } catch (std::out_of_range& e) {
39359       {
39360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39361       };
39362     } catch (std::exception& e) {
39363       {
39364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39365       };
39366     } catch (Dali::DaliException e) {
39367       {
39368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39369       };
39370     } catch (...) {
39371       {
39372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39373       };
39374     }
39375   }
39376
39377   jresult = result;
39378   return jresult;
39379 }
39380
39381
39382 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
39383   unsigned int jresult ;
39384   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39385   Dali::WheelEvent *arg2 = 0 ;
39386   bool result;
39387
39388   arg1 = (Dali::CustomActorImpl *)jarg1;
39389   arg2 = (Dali::WheelEvent *)jarg2;
39390   if (!arg2) {
39391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
39392     return 0;
39393   }
39394   {
39395     try {
39396       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
39397     } catch (std::out_of_range& e) {
39398       {
39399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39400       };
39401     } catch (std::exception& e) {
39402       {
39403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39404       };
39405     } catch (Dali::DaliException e) {
39406       {
39407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39408       };
39409     } catch (...) {
39410       {
39411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39412       };
39413     }
39414   }
39415
39416   jresult = result;
39417   return jresult;
39418 }
39419
39420
39421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
39422   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39423   Dali::Vector2 *arg2 = 0 ;
39424   Dali::RelayoutContainer *arg3 = 0 ;
39425
39426   arg1 = (Dali::CustomActorImpl *)jarg1;
39427   arg2 = (Dali::Vector2 *)jarg2;
39428   if (!arg2) {
39429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39430     return ;
39431   }
39432   arg3 = (Dali::RelayoutContainer *)jarg3;
39433   if (!arg3) {
39434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
39435     return ;
39436   }
39437   {
39438     try {
39439       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
39440     } catch (std::out_of_range& e) {
39441       {
39442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39443       };
39444     } catch (std::exception& e) {
39445       {
39446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39447       };
39448     } catch (Dali::DaliException e) {
39449       {
39450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39451       };
39452     } catch (...) {
39453       {
39454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39455       };
39456     }
39457   }
39458
39459 }
39460
39461
39462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
39463   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39464   Dali::ResizePolicy::Type arg2 ;
39465   Dali::Dimension::Type arg3 ;
39466
39467   arg1 = (Dali::CustomActorImpl *)jarg1;
39468   arg2 = (Dali::ResizePolicy::Type)jarg2;
39469   arg3 = (Dali::Dimension::Type)jarg3;
39470   {
39471     try {
39472       (arg1)->OnSetResizePolicy(arg2,arg3);
39473     } catch (std::out_of_range& e) {
39474       {
39475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39476       };
39477     } catch (std::exception& e) {
39478       {
39479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39480       };
39481     } catch (Dali::DaliException e) {
39482       {
39483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39484       };
39485     } catch (...) {
39486       {
39487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39488       };
39489     }
39490   }
39491
39492 }
39493
39494
39495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
39496   void * jresult ;
39497   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39498   Dali::Vector3 result;
39499
39500   arg1 = (Dali::CustomActorImpl *)jarg1;
39501   {
39502     try {
39503       result = (arg1)->GetNaturalSize();
39504     } catch (std::out_of_range& e) {
39505       {
39506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39507       };
39508     } catch (std::exception& e) {
39509       {
39510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39511       };
39512     } catch (Dali::DaliException e) {
39513       {
39514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39515       };
39516     } catch (...) {
39517       {
39518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39519       };
39520     }
39521   }
39522
39523   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
39524   return jresult;
39525 }
39526
39527
39528 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
39529   float jresult ;
39530   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39531   Dali::Actor *arg2 = 0 ;
39532   Dali::Dimension::Type arg3 ;
39533   float result;
39534
39535   arg1 = (Dali::CustomActorImpl *)jarg1;
39536   arg2 = (Dali::Actor *)jarg2;
39537   if (!arg2) {
39538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39539     return 0;
39540   }
39541   arg3 = (Dali::Dimension::Type)jarg3;
39542   {
39543     try {
39544       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
39545     } catch (std::out_of_range& e) {
39546       {
39547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39548       };
39549     } catch (std::exception& e) {
39550       {
39551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39552       };
39553     } catch (Dali::DaliException e) {
39554       {
39555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39556       };
39557     } catch (...) {
39558       {
39559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39560       };
39561     }
39562   }
39563
39564   jresult = result;
39565   return jresult;
39566 }
39567
39568
39569 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39570   float jresult ;
39571   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39572   float arg2 ;
39573   float result;
39574
39575   arg1 = (Dali::CustomActorImpl *)jarg1;
39576   arg2 = (float)jarg2;
39577   {
39578     try {
39579       result = (float)(arg1)->GetHeightForWidth(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 float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39605   float jresult ;
39606   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39607   float arg2 ;
39608   float result;
39609
39610   arg1 = (Dali::CustomActorImpl *)jarg1;
39611   arg2 = (float)jarg2;
39612   {
39613     try {
39614       result = (float)(arg1)->GetWidthForHeight(arg2);
39615     } catch (std::out_of_range& e) {
39616       {
39617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39618       };
39619     } catch (std::exception& e) {
39620       {
39621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39622       };
39623     } catch (Dali::DaliException e) {
39624       {
39625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39626       };
39627     } catch (...) {
39628       {
39629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39630       };
39631     }
39632   }
39633
39634   jresult = result;
39635   return jresult;
39636 }
39637
39638
39639 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39640   unsigned int jresult ;
39641   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39642   Dali::Dimension::Type arg2 ;
39643   bool result;
39644
39645   arg1 = (Dali::CustomActorImpl *)jarg1;
39646   arg2 = (Dali::Dimension::Type)jarg2;
39647   {
39648     try {
39649       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39650     } catch (std::out_of_range& e) {
39651       {
39652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39653       };
39654     } catch (std::exception& e) {
39655       {
39656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39657       };
39658     } catch (Dali::DaliException e) {
39659       {
39660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39661       };
39662     } catch (...) {
39663       {
39664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39665       };
39666     }
39667   }
39668
39669   jresult = result;
39670   return jresult;
39671 }
39672
39673
39674 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
39675   unsigned int jresult ;
39676   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39677   bool result;
39678
39679   arg1 = (Dali::CustomActorImpl *)jarg1;
39680   {
39681     try {
39682       result = (bool)(arg1)->RelayoutDependentOnChildren();
39683     } catch (std::out_of_range& e) {
39684       {
39685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39686       };
39687     } catch (std::exception& e) {
39688       {
39689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39690       };
39691     } catch (Dali::DaliException e) {
39692       {
39693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39694       };
39695     } catch (...) {
39696       {
39697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39698       };
39699     }
39700   }
39701
39702   jresult = result;
39703   return jresult;
39704 }
39705
39706
39707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
39708   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39709   Dali::Dimension::Type arg2 ;
39710
39711   arg1 = (Dali::CustomActorImpl *)jarg1;
39712   arg2 = (Dali::Dimension::Type)jarg2;
39713   {
39714     try {
39715       (arg1)->OnCalculateRelayoutSize(arg2);
39716     } catch (std::out_of_range& e) {
39717       {
39718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39719       };
39720     } catch (std::exception& e) {
39721       {
39722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39723       };
39724     } catch (Dali::DaliException e) {
39725       {
39726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39727       };
39728     } catch (...) {
39729       {
39730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39731       };
39732     }
39733   }
39734
39735 }
39736
39737
39738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
39739   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39740   float arg2 ;
39741   Dali::Dimension::Type arg3 ;
39742
39743   arg1 = (Dali::CustomActorImpl *)jarg1;
39744   arg2 = (float)jarg2;
39745   arg3 = (Dali::Dimension::Type)jarg3;
39746   {
39747     try {
39748       (arg1)->OnLayoutNegotiated(arg2,arg3);
39749     } catch (std::out_of_range& e) {
39750       {
39751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39752       };
39753     } catch (std::exception& e) {
39754       {
39755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39756       };
39757     } catch (Dali::DaliException e) {
39758       {
39759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39760       };
39761     } catch (...) {
39762       {
39763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39764       };
39765     }
39766   }
39767
39768 }
39769
39770
39771 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
39772   unsigned int jresult ;
39773   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39774   bool result;
39775
39776   arg1 = (Dali::CustomActorImpl *)jarg1;
39777   {
39778     try {
39779       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
39780     } catch (std::out_of_range& e) {
39781       {
39782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39783       };
39784     } catch (std::exception& e) {
39785       {
39786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39787       };
39788     } catch (Dali::DaliException e) {
39789       {
39790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39791       };
39792     } catch (...) {
39793       {
39794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39795       };
39796     }
39797   }
39798
39799   jresult = result;
39800   return jresult;
39801 }
39802
39803
39804 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
39805   unsigned int jresult ;
39806   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39807   bool result;
39808
39809   arg1 = (Dali::CustomActorImpl *)jarg1;
39810   {
39811     try {
39812       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
39813     } catch (std::out_of_range& e) {
39814       {
39815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39816       };
39817     } catch (std::exception& e) {
39818       {
39819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39820       };
39821     } catch (Dali::DaliException e) {
39822       {
39823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39824       };
39825     } catch (...) {
39826       {
39827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39828       };
39829     }
39830   }
39831
39832   jresult = result;
39833   return jresult;
39834 }
39835
39836
39837 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
39838   unsigned int jresult ;
39839   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39840   bool result;
39841
39842   arg1 = (Dali::CustomActorImpl *)jarg1;
39843   {
39844     try {
39845       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
39846     } catch (std::out_of_range& e) {
39847       {
39848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39849       };
39850     } catch (std::exception& e) {
39851       {
39852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39853       };
39854     } catch (Dali::DaliException e) {
39855       {
39856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39857       };
39858     } catch (...) {
39859       {
39860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39861       };
39862     }
39863   }
39864
39865   jresult = result;
39866   return jresult;
39867 }
39868
39869
39870 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
39871   unsigned int jresult ;
39872   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39873   bool result;
39874
39875   arg1 = (Dali::CustomActorImpl *)jarg1;
39876   {
39877     try {
39878       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
39879     } catch (std::out_of_range& e) {
39880       {
39881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39882       };
39883     } catch (std::exception& e) {
39884       {
39885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39886       };
39887     } catch (Dali::DaliException e) {
39888       {
39889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39890       };
39891     } catch (...) {
39892       {
39893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39894       };
39895     }
39896   }
39897
39898   jresult = result;
39899   return jresult;
39900 }
39901
39902
39903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
39904   void * jresult ;
39905   Dali::CustomActor *result = 0 ;
39906
39907   {
39908     try {
39909       result = (Dali::CustomActor *)new Dali::CustomActor();
39910     } catch (std::out_of_range& e) {
39911       {
39912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39913       };
39914     } catch (std::exception& e) {
39915       {
39916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39917       };
39918     } catch (Dali::DaliException e) {
39919       {
39920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39921       };
39922     } catch (...) {
39923       {
39924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39925       };
39926     }
39927   }
39928
39929   jresult = (void *)result;
39930   return jresult;
39931 }
39932
39933
39934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
39935   void * jresult ;
39936   Dali::BaseHandle arg1 ;
39937   Dali::BaseHandle *argp1 ;
39938   Dali::CustomActor result;
39939
39940   argp1 = (Dali::BaseHandle *)jarg1;
39941   if (!argp1) {
39942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39943     return 0;
39944   }
39945   arg1 = *argp1;
39946   {
39947     try {
39948       result = Dali::CustomActor::DownCast(arg1);
39949     } catch (std::out_of_range& e) {
39950       {
39951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39952       };
39953     } catch (std::exception& e) {
39954       {
39955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39956       };
39957     } catch (Dali::DaliException e) {
39958       {
39959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39960       };
39961     } catch (...) {
39962       {
39963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39964       };
39965     }
39966   }
39967
39968   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39969   return jresult;
39970 }
39971
39972
39973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
39974   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
39975
39976   arg1 = (Dali::CustomActor *)jarg1;
39977   {
39978     try {
39979       delete arg1;
39980     } catch (std::out_of_range& e) {
39981       {
39982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39983       };
39984     } catch (std::exception& e) {
39985       {
39986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39987       };
39988     } catch (Dali::DaliException e) {
39989       {
39990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39991       };
39992     } catch (...) {
39993       {
39994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39995       };
39996     }
39997   }
39998
39999 }
40000
40001
40002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
40003   void * jresult ;
40004   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40005   Dali::CustomActorImpl *result = 0 ;
40006
40007   arg1 = (Dali::CustomActor *)jarg1;
40008   {
40009     try {
40010       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
40011     } catch (std::out_of_range& e) {
40012       {
40013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40014       };
40015     } catch (std::exception& e) {
40016       {
40017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40018       };
40019     } catch (Dali::DaliException e) {
40020       {
40021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40022       };
40023     } catch (...) {
40024       {
40025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40026       };
40027     }
40028   }
40029
40030   jresult = (void *)result;
40031   return jresult;
40032 }
40033
40034
40035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
40036   void * jresult ;
40037   Dali::CustomActorImpl *arg1 = 0 ;
40038   Dali::CustomActor *result = 0 ;
40039
40040   arg1 = (Dali::CustomActorImpl *)jarg1;
40041   if (!arg1) {
40042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
40043     return 0;
40044   }
40045   {
40046     try {
40047       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
40048     } catch (std::out_of_range& e) {
40049       {
40050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40051       };
40052     } catch (std::exception& e) {
40053       {
40054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40055       };
40056     } catch (Dali::DaliException e) {
40057       {
40058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40059       };
40060     } catch (...) {
40061       {
40062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40063       };
40064     }
40065   }
40066
40067   jresult = (void *)result;
40068   return jresult;
40069 }
40070
40071
40072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
40073   void * jresult ;
40074   Dali::CustomActor *arg1 = 0 ;
40075   Dali::CustomActor *result = 0 ;
40076
40077   arg1 = (Dali::CustomActor *)jarg1;
40078   if (!arg1) {
40079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40080     return 0;
40081   }
40082   {
40083     try {
40084       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
40085     } catch (std::out_of_range& e) {
40086       {
40087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40088       };
40089     } catch (std::exception& e) {
40090       {
40091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40092       };
40093     } catch (Dali::DaliException e) {
40094       {
40095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40096       };
40097     } catch (...) {
40098       {
40099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40100       };
40101     }
40102   }
40103
40104   jresult = (void *)result;
40105   return jresult;
40106 }
40107
40108
40109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
40110   void * jresult ;
40111   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40112   Dali::CustomActor *arg2 = 0 ;
40113   Dali::CustomActor *result = 0 ;
40114
40115   arg1 = (Dali::CustomActor *)jarg1;
40116   arg2 = (Dali::CustomActor *)jarg2;
40117   if (!arg2) {
40118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40119     return 0;
40120   }
40121   {
40122     try {
40123       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
40124     } catch (std::out_of_range& e) {
40125       {
40126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40127       };
40128     } catch (std::exception& e) {
40129       {
40130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40131       };
40132     } catch (Dali::DaliException e) {
40133       {
40134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40135       };
40136     } catch (...) {
40137       {
40138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40139       };
40140     }
40141   }
40142
40143   jresult = (void *)result;
40144   return jresult;
40145 }
40146
40147
40148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
40149   int jresult ;
40150   int result;
40151
40152   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
40153   jresult = (int)result;
40154   return jresult;
40155 }
40156
40157
40158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
40159   int jresult ;
40160   int result;
40161
40162   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
40163   jresult = (int)result;
40164   return jresult;
40165 }
40166
40167
40168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
40169   int jresult ;
40170   int result;
40171
40172   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
40173   jresult = (int)result;
40174   return jresult;
40175 }
40176
40177
40178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
40179   int jresult ;
40180   int result;
40181
40182   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
40183   jresult = (int)result;
40184   return jresult;
40185 }
40186
40187
40188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
40189   int jresult ;
40190   int result;
40191
40192   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
40193   jresult = (int)result;
40194   return jresult;
40195 }
40196
40197
40198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
40199   int jresult ;
40200   int result;
40201
40202   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
40203   jresult = (int)result;
40204   return jresult;
40205 }
40206
40207
40208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
40209   int jresult ;
40210   int result;
40211
40212   result = (int)Dali::PanGestureDetector::Property::PANNING;
40213   jresult = (int)result;
40214   return jresult;
40215 }
40216
40217
40218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
40219   void * jresult ;
40220   Dali::PanGestureDetector::Property *result = 0 ;
40221
40222   {
40223     try {
40224       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
40225     } catch (std::out_of_range& e) {
40226       {
40227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40228       };
40229     } catch (std::exception& e) {
40230       {
40231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40232       };
40233     } catch (Dali::DaliException e) {
40234       {
40235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40236       };
40237     } catch (...) {
40238       {
40239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40240       };
40241     }
40242   }
40243
40244   jresult = (void *)result;
40245   return jresult;
40246 }
40247
40248
40249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
40250   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
40251
40252   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
40253   {
40254     try {
40255       delete arg1;
40256     } catch (std::out_of_range& e) {
40257       {
40258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40259       };
40260     } catch (std::exception& e) {
40261       {
40262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40263       };
40264     } catch (Dali::DaliException e) {
40265       {
40266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40267       };
40268     } catch (...) {
40269       {
40270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40271       };
40272     }
40273   }
40274
40275 }
40276
40277
40278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
40279   void * jresult ;
40280   Dali::Radian *result = 0 ;
40281
40282   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
40283   jresult = (void *)result;
40284   return jresult;
40285 }
40286
40287
40288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
40289   void * jresult ;
40290   Dali::Radian *result = 0 ;
40291
40292   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
40293   jresult = (void *)result;
40294   return jresult;
40295 }
40296
40297
40298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
40299   void * jresult ;
40300   Dali::Radian *result = 0 ;
40301
40302   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
40303   jresult = (void *)result;
40304   return jresult;
40305 }
40306
40307
40308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
40309   void * jresult ;
40310   Dali::Radian *result = 0 ;
40311
40312   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
40313   jresult = (void *)result;
40314   return jresult;
40315 }
40316
40317
40318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
40319   void * jresult ;
40320   Dali::Radian *result = 0 ;
40321
40322   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
40323   jresult = (void *)result;
40324   return jresult;
40325 }
40326
40327
40328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
40329   void * jresult ;
40330   Dali::Radian *result = 0 ;
40331
40332   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
40333   jresult = (void *)result;
40334   return jresult;
40335 }
40336
40337
40338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
40339   void * jresult ;
40340   Dali::Radian *result = 0 ;
40341
40342   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
40343   jresult = (void *)result;
40344   return jresult;
40345 }
40346
40347
40348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
40349   void * jresult ;
40350   Dali::PanGestureDetector *result = 0 ;
40351
40352   {
40353     try {
40354       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
40355     } catch (std::out_of_range& e) {
40356       {
40357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40358       };
40359     } catch (std::exception& e) {
40360       {
40361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40362       };
40363     } catch (Dali::DaliException e) {
40364       {
40365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40366       };
40367     } catch (...) {
40368       {
40369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40370       };
40371     }
40372   }
40373
40374   jresult = (void *)result;
40375   return jresult;
40376 }
40377
40378
40379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
40380   void * jresult ;
40381   Dali::PanGestureDetector result;
40382
40383   {
40384     try {
40385       result = Dali::PanGestureDetector::New();
40386     } catch (std::out_of_range& e) {
40387       {
40388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40389       };
40390     } catch (std::exception& e) {
40391       {
40392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40393       };
40394     } catch (Dali::DaliException e) {
40395       {
40396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40397       };
40398     } catch (...) {
40399       {
40400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40401       };
40402     }
40403   }
40404
40405   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40406   return jresult;
40407 }
40408
40409
40410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
40411   void * jresult ;
40412   Dali::BaseHandle arg1 ;
40413   Dali::BaseHandle *argp1 ;
40414   Dali::PanGestureDetector result;
40415
40416   argp1 = (Dali::BaseHandle *)jarg1;
40417   if (!argp1) {
40418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40419     return 0;
40420   }
40421   arg1 = *argp1;
40422   {
40423     try {
40424       result = Dali::PanGestureDetector::DownCast(arg1);
40425     } catch (std::out_of_range& e) {
40426       {
40427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40428       };
40429     } catch (std::exception& e) {
40430       {
40431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40432       };
40433     } catch (Dali::DaliException e) {
40434       {
40435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40436       };
40437     } catch (...) {
40438       {
40439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40440       };
40441     }
40442   }
40443
40444   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40445   return jresult;
40446 }
40447
40448
40449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
40450   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40451
40452   arg1 = (Dali::PanGestureDetector *)jarg1;
40453   {
40454     try {
40455       delete arg1;
40456     } catch (std::out_of_range& e) {
40457       {
40458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40459       };
40460     } catch (std::exception& e) {
40461       {
40462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40463       };
40464     } catch (Dali::DaliException e) {
40465       {
40466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40467       };
40468     } catch (...) {
40469       {
40470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40471       };
40472     }
40473   }
40474
40475 }
40476
40477
40478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
40479   void * jresult ;
40480   Dali::PanGestureDetector *arg1 = 0 ;
40481   Dali::PanGestureDetector *result = 0 ;
40482
40483   arg1 = (Dali::PanGestureDetector *)jarg1;
40484   if (!arg1) {
40485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40486     return 0;
40487   }
40488   {
40489     try {
40490       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
40491     } catch (std::out_of_range& e) {
40492       {
40493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40494       };
40495     } catch (std::exception& e) {
40496       {
40497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40498       };
40499     } catch (Dali::DaliException e) {
40500       {
40501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40502       };
40503     } catch (...) {
40504       {
40505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40506       };
40507     }
40508   }
40509
40510   jresult = (void *)result;
40511   return jresult;
40512 }
40513
40514
40515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
40516   void * jresult ;
40517   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40518   Dali::PanGestureDetector *arg2 = 0 ;
40519   Dali::PanGestureDetector *result = 0 ;
40520
40521   arg1 = (Dali::PanGestureDetector *)jarg1;
40522   arg2 = (Dali::PanGestureDetector *)jarg2;
40523   if (!arg2) {
40524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40525     return 0;
40526   }
40527   {
40528     try {
40529       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
40530     } catch (std::out_of_range& e) {
40531       {
40532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40533       };
40534     } catch (std::exception& e) {
40535       {
40536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40537       };
40538     } catch (Dali::DaliException e) {
40539       {
40540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40541       };
40542     } catch (...) {
40543       {
40544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40545       };
40546     }
40547   }
40548
40549   jresult = (void *)result;
40550   return jresult;
40551 }
40552
40553
40554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
40555   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40556   unsigned int arg2 ;
40557
40558   arg1 = (Dali::PanGestureDetector *)jarg1;
40559   arg2 = (unsigned int)jarg2;
40560   {
40561     try {
40562       (arg1)->SetMinimumTouchesRequired(arg2);
40563     } catch (std::out_of_range& e) {
40564       {
40565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40566       };
40567     } catch (std::exception& e) {
40568       {
40569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40570       };
40571     } catch (Dali::DaliException e) {
40572       {
40573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40574       };
40575     } catch (...) {
40576       {
40577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40578       };
40579     }
40580   }
40581
40582 }
40583
40584
40585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
40586   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40587   unsigned int arg2 ;
40588
40589   arg1 = (Dali::PanGestureDetector *)jarg1;
40590   arg2 = (unsigned int)jarg2;
40591   {
40592     try {
40593       (arg1)->SetMaximumTouchesRequired(arg2);
40594     } catch (std::out_of_range& e) {
40595       {
40596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40597       };
40598     } catch (std::exception& e) {
40599       {
40600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40601       };
40602     } catch (Dali::DaliException e) {
40603       {
40604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40605       };
40606     } catch (...) {
40607       {
40608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40609       };
40610     }
40611   }
40612
40613 }
40614
40615
40616 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40617   unsigned int jresult ;
40618   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40619   unsigned int result;
40620
40621   arg1 = (Dali::PanGestureDetector *)jarg1;
40622   {
40623     try {
40624       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40625     } catch (std::out_of_range& e) {
40626       {
40627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40628       };
40629     } catch (std::exception& e) {
40630       {
40631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40632       };
40633     } catch (Dali::DaliException e) {
40634       {
40635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40636       };
40637     } catch (...) {
40638       {
40639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40640       };
40641     }
40642   }
40643
40644   jresult = result;
40645   return jresult;
40646 }
40647
40648
40649 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40650   unsigned int jresult ;
40651   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40652   unsigned int result;
40653
40654   arg1 = (Dali::PanGestureDetector *)jarg1;
40655   {
40656     try {
40657       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
40658     } catch (std::out_of_range& e) {
40659       {
40660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40661       };
40662     } catch (std::exception& e) {
40663       {
40664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40665       };
40666     } catch (Dali::DaliException e) {
40667       {
40668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40669       };
40670     } catch (...) {
40671       {
40672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40673       };
40674     }
40675   }
40676
40677   jresult = result;
40678   return jresult;
40679 }
40680
40681
40682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40683   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40684   Dali::Radian arg2 ;
40685   Dali::Radian arg3 ;
40686   Dali::Radian *argp2 ;
40687   Dali::Radian *argp3 ;
40688
40689   arg1 = (Dali::PanGestureDetector *)jarg1;
40690   argp2 = (Dali::Radian *)jarg2;
40691   if (!argp2) {
40692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40693     return ;
40694   }
40695   arg2 = *argp2;
40696   argp3 = (Dali::Radian *)jarg3;
40697   if (!argp3) {
40698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40699     return ;
40700   }
40701   arg3 = *argp3;
40702   {
40703     try {
40704       (arg1)->AddAngle(arg2,arg3);
40705     } catch (std::out_of_range& e) {
40706       {
40707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40708       };
40709     } catch (std::exception& e) {
40710       {
40711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40712       };
40713     } catch (Dali::DaliException e) {
40714       {
40715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40716       };
40717     } catch (...) {
40718       {
40719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40720       };
40721     }
40722   }
40723
40724 }
40725
40726
40727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
40728   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40729   Dali::Radian arg2 ;
40730   Dali::Radian *argp2 ;
40731
40732   arg1 = (Dali::PanGestureDetector *)jarg1;
40733   argp2 = (Dali::Radian *)jarg2;
40734   if (!argp2) {
40735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40736     return ;
40737   }
40738   arg2 = *argp2;
40739   {
40740     try {
40741       (arg1)->AddAngle(arg2);
40742     } catch (std::out_of_range& e) {
40743       {
40744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40745       };
40746     } catch (std::exception& e) {
40747       {
40748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40749       };
40750     } catch (Dali::DaliException e) {
40751       {
40752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40753       };
40754     } catch (...) {
40755       {
40756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40757       };
40758     }
40759   }
40760
40761 }
40762
40763
40764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40765   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40766   Dali::Radian arg2 ;
40767   Dali::Radian arg3 ;
40768   Dali::Radian *argp2 ;
40769   Dali::Radian *argp3 ;
40770
40771   arg1 = (Dali::PanGestureDetector *)jarg1;
40772   argp2 = (Dali::Radian *)jarg2;
40773   if (!argp2) {
40774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40775     return ;
40776   }
40777   arg2 = *argp2;
40778   argp3 = (Dali::Radian *)jarg3;
40779   if (!argp3) {
40780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40781     return ;
40782   }
40783   arg3 = *argp3;
40784   {
40785     try {
40786       (arg1)->AddDirection(arg2,arg3);
40787     } catch (std::out_of_range& e) {
40788       {
40789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40790       };
40791     } catch (std::exception& e) {
40792       {
40793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40794       };
40795     } catch (Dali::DaliException e) {
40796       {
40797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40798       };
40799     } catch (...) {
40800       {
40801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40802       };
40803     }
40804   }
40805
40806 }
40807
40808
40809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
40810   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40811   Dali::Radian arg2 ;
40812   Dali::Radian *argp2 ;
40813
40814   arg1 = (Dali::PanGestureDetector *)jarg1;
40815   argp2 = (Dali::Radian *)jarg2;
40816   if (!argp2) {
40817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40818     return ;
40819   }
40820   arg2 = *argp2;
40821   {
40822     try {
40823       (arg1)->AddDirection(arg2);
40824     } catch (std::out_of_range& e) {
40825       {
40826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40827       };
40828     } catch (std::exception& e) {
40829       {
40830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40831       };
40832     } catch (Dali::DaliException e) {
40833       {
40834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40835       };
40836     } catch (...) {
40837       {
40838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40839       };
40840     }
40841   }
40842
40843 }
40844
40845
40846 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
40847   unsigned long jresult ;
40848   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40849   size_t result;
40850
40851   arg1 = (Dali::PanGestureDetector *)jarg1;
40852   {
40853     try {
40854       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
40855     } catch (std::out_of_range& e) {
40856       {
40857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40858       };
40859     } catch (std::exception& e) {
40860       {
40861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40862       };
40863     } catch (Dali::DaliException e) {
40864       {
40865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40866       };
40867     } catch (...) {
40868       {
40869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40870       };
40871     }
40872   }
40873
40874   jresult = (unsigned long)result;
40875   return jresult;
40876 }
40877
40878
40879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
40880   void * jresult ;
40881   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40882   size_t arg2 ;
40883   Dali::PanGestureDetector::AngleThresholdPair result;
40884
40885   arg1 = (Dali::PanGestureDetector *)jarg1;
40886   arg2 = (size_t)jarg2;
40887   {
40888     try {
40889       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
40890     } catch (std::out_of_range& e) {
40891       {
40892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40893       };
40894     } catch (std::exception& e) {
40895       {
40896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40897       };
40898     } catch (Dali::DaliException e) {
40899       {
40900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40901       };
40902     } catch (...) {
40903       {
40904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40905       };
40906     }
40907   }
40908
40909   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
40910   return jresult;
40911 }
40912
40913
40914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
40915   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40916
40917   arg1 = (Dali::PanGestureDetector *)jarg1;
40918   {
40919     try {
40920       (arg1)->ClearAngles();
40921     } catch (std::out_of_range& e) {
40922       {
40923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40924       };
40925     } catch (std::exception& e) {
40926       {
40927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40928       };
40929     } catch (Dali::DaliException e) {
40930       {
40931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40932       };
40933     } catch (...) {
40934       {
40935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40936       };
40937     }
40938   }
40939
40940 }
40941
40942
40943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
40944   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40945   Dali::Radian arg2 ;
40946   Dali::Radian *argp2 ;
40947
40948   arg1 = (Dali::PanGestureDetector *)jarg1;
40949   argp2 = (Dali::Radian *)jarg2;
40950   if (!argp2) {
40951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40952     return ;
40953   }
40954   arg2 = *argp2;
40955   {
40956     try {
40957       (arg1)->RemoveAngle(arg2);
40958     } catch (std::out_of_range& e) {
40959       {
40960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40961       };
40962     } catch (std::exception& e) {
40963       {
40964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40965       };
40966     } catch (Dali::DaliException e) {
40967       {
40968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40969       };
40970     } catch (...) {
40971       {
40972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40973       };
40974     }
40975   }
40976
40977 }
40978
40979
40980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
40981   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40982   Dali::Radian arg2 ;
40983   Dali::Radian *argp2 ;
40984
40985   arg1 = (Dali::PanGestureDetector *)jarg1;
40986   argp2 = (Dali::Radian *)jarg2;
40987   if (!argp2) {
40988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40989     return ;
40990   }
40991   arg2 = *argp2;
40992   {
40993     try {
40994       (arg1)->RemoveDirection(arg2);
40995     } catch (std::out_of_range& e) {
40996       {
40997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40998       };
40999     } catch (std::exception& e) {
41000       {
41001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41002       };
41003     } catch (Dali::DaliException e) {
41004       {
41005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41006       };
41007     } catch (...) {
41008       {
41009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41010       };
41011     }
41012   }
41013
41014 }
41015
41016
41017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
41018   void * jresult ;
41019   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41020   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
41021
41022   arg1 = (Dali::PanGestureDetector *)jarg1;
41023   {
41024     try {
41025       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41026     } catch (std::out_of_range& e) {
41027       {
41028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41029       };
41030     } catch (std::exception& e) {
41031       {
41032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41033       };
41034     } catch (Dali::DaliException e) {
41035       {
41036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41037       };
41038     } catch (...) {
41039       {
41040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41041       };
41042     }
41043   }
41044
41045   jresult = (void *)result;
41046   return jresult;
41047 }
41048
41049
41050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
41051   Dali::PanGesture *arg1 = 0 ;
41052
41053   arg1 = (Dali::PanGesture *)jarg1;
41054   if (!arg1) {
41055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41056     return ;
41057   }
41058   {
41059     try {
41060       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
41061     } catch (std::out_of_range& e) {
41062       {
41063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41064       };
41065     } catch (std::exception& e) {
41066       {
41067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41068       };
41069     } catch (Dali::DaliException e) {
41070       {
41071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41072       };
41073     } catch (...) {
41074       {
41075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41076       };
41077     }
41078   }
41079
41080 }
41081
41082
41083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
41084   void * jresult ;
41085   Dali::PanGesture *result = 0 ;
41086
41087   {
41088     try {
41089       result = (Dali::PanGesture *)new Dali::PanGesture();
41090     } catch (std::out_of_range& e) {
41091       {
41092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41093       };
41094     } catch (std::exception& e) {
41095       {
41096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41097       };
41098     } catch (Dali::DaliException e) {
41099       {
41100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41101       };
41102     } catch (...) {
41103       {
41104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41105       };
41106     }
41107   }
41108
41109   jresult = (void *)result;
41110   return jresult;
41111 }
41112
41113
41114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
41115   void * jresult ;
41116   Dali::Gesture::State arg1 ;
41117   Dali::PanGesture *result = 0 ;
41118
41119   arg1 = (Dali::Gesture::State)jarg1;
41120   {
41121     try {
41122       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
41123     } catch (std::out_of_range& e) {
41124       {
41125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41126       };
41127     } catch (std::exception& e) {
41128       {
41129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41130       };
41131     } catch (Dali::DaliException e) {
41132       {
41133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41134       };
41135     } catch (...) {
41136       {
41137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41138       };
41139     }
41140   }
41141
41142   jresult = (void *)result;
41143   return jresult;
41144 }
41145
41146
41147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
41148   void * jresult ;
41149   Dali::PanGesture *arg1 = 0 ;
41150   Dali::PanGesture *result = 0 ;
41151
41152   arg1 = (Dali::PanGesture *)jarg1;
41153   if (!arg1) {
41154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41155     return 0;
41156   }
41157   {
41158     try {
41159       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
41160     } catch (std::out_of_range& e) {
41161       {
41162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41163       };
41164     } catch (std::exception& e) {
41165       {
41166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41167       };
41168     } catch (Dali::DaliException e) {
41169       {
41170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41171       };
41172     } catch (...) {
41173       {
41174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41175       };
41176     }
41177   }
41178
41179   jresult = (void *)result;
41180   return jresult;
41181 }
41182
41183
41184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
41185   void * jresult ;
41186   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41187   Dali::PanGesture *arg2 = 0 ;
41188   Dali::PanGesture *result = 0 ;
41189
41190   arg1 = (Dali::PanGesture *)jarg1;
41191   arg2 = (Dali::PanGesture *)jarg2;
41192   if (!arg2) {
41193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41194     return 0;
41195   }
41196   {
41197     try {
41198       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
41199     } catch (std::out_of_range& e) {
41200       {
41201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41202       };
41203     } catch (std::exception& e) {
41204       {
41205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41206       };
41207     } catch (Dali::DaliException e) {
41208       {
41209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41210       };
41211     } catch (...) {
41212       {
41213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41214       };
41215     }
41216   }
41217
41218   jresult = (void *)result;
41219   return jresult;
41220 }
41221
41222
41223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
41224   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41225
41226   arg1 = (Dali::PanGesture *)jarg1;
41227   {
41228     try {
41229       delete arg1;
41230     } catch (std::out_of_range& e) {
41231       {
41232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41233       };
41234     } catch (std::exception& e) {
41235       {
41236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41237       };
41238     } catch (Dali::DaliException e) {
41239       {
41240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41241       };
41242     } catch (...) {
41243       {
41244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41245       };
41246     }
41247   }
41248
41249 }
41250
41251
41252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
41253   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41254   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41255
41256   arg1 = (Dali::PanGesture *)jarg1;
41257   arg2 = (Dali::Vector2 *)jarg2;
41258   if (arg1) (arg1)->velocity = *arg2;
41259 }
41260
41261
41262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
41263   void * jresult ;
41264   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41265   Dali::Vector2 *result = 0 ;
41266
41267   arg1 = (Dali::PanGesture *)jarg1;
41268   result = (Dali::Vector2 *)& ((arg1)->velocity);
41269   jresult = (void *)result;
41270   return jresult;
41271 }
41272
41273
41274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
41275   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41276   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41277
41278   arg1 = (Dali::PanGesture *)jarg1;
41279   arg2 = (Dali::Vector2 *)jarg2;
41280   if (arg1) (arg1)->displacement = *arg2;
41281 }
41282
41283
41284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
41285   void * jresult ;
41286   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41287   Dali::Vector2 *result = 0 ;
41288
41289   arg1 = (Dali::PanGesture *)jarg1;
41290   result = (Dali::Vector2 *)& ((arg1)->displacement);
41291   jresult = (void *)result;
41292   return jresult;
41293 }
41294
41295
41296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
41297   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41298   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41299
41300   arg1 = (Dali::PanGesture *)jarg1;
41301   arg2 = (Dali::Vector2 *)jarg2;
41302   if (arg1) (arg1)->position = *arg2;
41303 }
41304
41305
41306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
41307   void * jresult ;
41308   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41309   Dali::Vector2 *result = 0 ;
41310
41311   arg1 = (Dali::PanGesture *)jarg1;
41312   result = (Dali::Vector2 *)& ((arg1)->position);
41313   jresult = (void *)result;
41314   return jresult;
41315 }
41316
41317
41318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
41319   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41320   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41321
41322   arg1 = (Dali::PanGesture *)jarg1;
41323   arg2 = (Dali::Vector2 *)jarg2;
41324   if (arg1) (arg1)->screenVelocity = *arg2;
41325 }
41326
41327
41328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
41329   void * jresult ;
41330   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41331   Dali::Vector2 *result = 0 ;
41332
41333   arg1 = (Dali::PanGesture *)jarg1;
41334   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
41335   jresult = (void *)result;
41336   return jresult;
41337 }
41338
41339
41340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
41341   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41342   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41343
41344   arg1 = (Dali::PanGesture *)jarg1;
41345   arg2 = (Dali::Vector2 *)jarg2;
41346   if (arg1) (arg1)->screenDisplacement = *arg2;
41347 }
41348
41349
41350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
41351   void * jresult ;
41352   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41353   Dali::Vector2 *result = 0 ;
41354
41355   arg1 = (Dali::PanGesture *)jarg1;
41356   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
41357   jresult = (void *)result;
41358   return jresult;
41359 }
41360
41361
41362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
41363   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41364   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41365
41366   arg1 = (Dali::PanGesture *)jarg1;
41367   arg2 = (Dali::Vector2 *)jarg2;
41368   if (arg1) (arg1)->screenPosition = *arg2;
41369 }
41370
41371
41372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
41373   void * jresult ;
41374   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41375   Dali::Vector2 *result = 0 ;
41376
41377   arg1 = (Dali::PanGesture *)jarg1;
41378   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
41379   jresult = (void *)result;
41380   return jresult;
41381 }
41382
41383
41384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
41385   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41386   unsigned int arg2 ;
41387
41388   arg1 = (Dali::PanGesture *)jarg1;
41389   arg2 = (unsigned int)jarg2;
41390   if (arg1) (arg1)->numberOfTouches = arg2;
41391 }
41392
41393
41394 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
41395   unsigned int jresult ;
41396   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41397   unsigned int result;
41398
41399   arg1 = (Dali::PanGesture *)jarg1;
41400   result = (unsigned int) ((arg1)->numberOfTouches);
41401   jresult = result;
41402   return jresult;
41403 }
41404
41405
41406 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
41407   float jresult ;
41408   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41409   float result;
41410
41411   arg1 = (Dali::PanGesture *)jarg1;
41412   {
41413     try {
41414       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
41415     } catch (std::out_of_range& e) {
41416       {
41417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41418       };
41419     } catch (std::exception& e) {
41420       {
41421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41422       };
41423     } catch (Dali::DaliException e) {
41424       {
41425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41426       };
41427     } catch (...) {
41428       {
41429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41430       };
41431     }
41432   }
41433
41434   jresult = result;
41435   return jresult;
41436 }
41437
41438
41439 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
41440   float jresult ;
41441   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41442   float result;
41443
41444   arg1 = (Dali::PanGesture *)jarg1;
41445   {
41446     try {
41447       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
41448     } catch (std::out_of_range& e) {
41449       {
41450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41451       };
41452     } catch (std::exception& e) {
41453       {
41454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41455       };
41456     } catch (Dali::DaliException e) {
41457       {
41458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41459       };
41460     } catch (...) {
41461       {
41462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41463       };
41464     }
41465   }
41466
41467   jresult = result;
41468   return jresult;
41469 }
41470
41471
41472 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
41473   float jresult ;
41474   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41475   float result;
41476
41477   arg1 = (Dali::PanGesture *)jarg1;
41478   {
41479     try {
41480       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
41481     } catch (std::out_of_range& e) {
41482       {
41483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41484       };
41485     } catch (std::exception& e) {
41486       {
41487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41488       };
41489     } catch (Dali::DaliException e) {
41490       {
41491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41492       };
41493     } catch (...) {
41494       {
41495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41496       };
41497     }
41498   }
41499
41500   jresult = result;
41501   return jresult;
41502 }
41503
41504
41505 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
41506   float jresult ;
41507   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41508   float result;
41509
41510   arg1 = (Dali::PanGesture *)jarg1;
41511   {
41512     try {
41513       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
41514     } catch (std::out_of_range& e) {
41515       {
41516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41517       };
41518     } catch (std::exception& e) {
41519       {
41520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41521       };
41522     } catch (Dali::DaliException e) {
41523       {
41524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41525       };
41526     } catch (...) {
41527       {
41528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41529       };
41530     }
41531   }
41532
41533   jresult = result;
41534   return jresult;
41535 }
41536
41537
41538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
41539   void * jresult ;
41540   Dali::PinchGestureDetector *result = 0 ;
41541
41542   {
41543     try {
41544       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
41545     } catch (std::out_of_range& e) {
41546       {
41547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41548       };
41549     } catch (std::exception& e) {
41550       {
41551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41552       };
41553     } catch (Dali::DaliException e) {
41554       {
41555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41556       };
41557     } catch (...) {
41558       {
41559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41560       };
41561     }
41562   }
41563
41564   jresult = (void *)result;
41565   return jresult;
41566 }
41567
41568
41569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
41570   void * jresult ;
41571   Dali::PinchGestureDetector result;
41572
41573   {
41574     try {
41575       result = Dali::PinchGestureDetector::New();
41576     } catch (std::out_of_range& e) {
41577       {
41578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41579       };
41580     } catch (std::exception& e) {
41581       {
41582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41583       };
41584     } catch (Dali::DaliException e) {
41585       {
41586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41587       };
41588     } catch (...) {
41589       {
41590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41591       };
41592     }
41593   }
41594
41595   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41596   return jresult;
41597 }
41598
41599
41600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
41601   void * jresult ;
41602   Dali::BaseHandle arg1 ;
41603   Dali::BaseHandle *argp1 ;
41604   Dali::PinchGestureDetector result;
41605
41606   argp1 = (Dali::BaseHandle *)jarg1;
41607   if (!argp1) {
41608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41609     return 0;
41610   }
41611   arg1 = *argp1;
41612   {
41613     try {
41614       result = Dali::PinchGestureDetector::DownCast(arg1);
41615     } catch (std::out_of_range& e) {
41616       {
41617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41618       };
41619     } catch (std::exception& e) {
41620       {
41621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41622       };
41623     } catch (Dali::DaliException e) {
41624       {
41625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41626       };
41627     } catch (...) {
41628       {
41629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41630       };
41631     }
41632   }
41633
41634   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41635   return jresult;
41636 }
41637
41638
41639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41640   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41641
41642   arg1 = (Dali::PinchGestureDetector *)jarg1;
41643   {
41644     try {
41645       delete arg1;
41646     } catch (std::out_of_range& e) {
41647       {
41648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41649       };
41650     } catch (std::exception& e) {
41651       {
41652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41653       };
41654     } catch (Dali::DaliException e) {
41655       {
41656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41657       };
41658     } catch (...) {
41659       {
41660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41661       };
41662     }
41663   }
41664
41665 }
41666
41667
41668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
41669   void * jresult ;
41670   Dali::PinchGestureDetector *arg1 = 0 ;
41671   Dali::PinchGestureDetector *result = 0 ;
41672
41673   arg1 = (Dali::PinchGestureDetector *)jarg1;
41674   if (!arg1) {
41675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41676     return 0;
41677   }
41678   {
41679     try {
41680       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
41681     } catch (std::out_of_range& e) {
41682       {
41683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41684       };
41685     } catch (std::exception& e) {
41686       {
41687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41688       };
41689     } catch (Dali::DaliException e) {
41690       {
41691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41692       };
41693     } catch (...) {
41694       {
41695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41696       };
41697     }
41698   }
41699
41700   jresult = (void *)result;
41701   return jresult;
41702 }
41703
41704
41705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
41706   void * jresult ;
41707   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41708   Dali::PinchGestureDetector *arg2 = 0 ;
41709   Dali::PinchGestureDetector *result = 0 ;
41710
41711   arg1 = (Dali::PinchGestureDetector *)jarg1;
41712   arg2 = (Dali::PinchGestureDetector *)jarg2;
41713   if (!arg2) {
41714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41715     return 0;
41716   }
41717   {
41718     try {
41719       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
41720     } catch (std::out_of_range& e) {
41721       {
41722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41723       };
41724     } catch (std::exception& e) {
41725       {
41726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41727       };
41728     } catch (Dali::DaliException e) {
41729       {
41730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41731       };
41732     } catch (...) {
41733       {
41734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41735       };
41736     }
41737   }
41738
41739   jresult = (void *)result;
41740   return jresult;
41741 }
41742
41743
41744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
41745   void * jresult ;
41746   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41747   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
41748
41749   arg1 = (Dali::PinchGestureDetector *)jarg1;
41750   {
41751     try {
41752       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41753     } catch (std::out_of_range& e) {
41754       {
41755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41756       };
41757     } catch (std::exception& e) {
41758       {
41759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41760       };
41761     } catch (Dali::DaliException e) {
41762       {
41763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41764       };
41765     } catch (...) {
41766       {
41767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41768       };
41769     }
41770   }
41771
41772   jresult = (void *)result;
41773   return jresult;
41774 }
41775
41776
41777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
41778   void * jresult ;
41779   Dali::Gesture::State arg1 ;
41780   Dali::PinchGesture *result = 0 ;
41781
41782   arg1 = (Dali::Gesture::State)jarg1;
41783   {
41784     try {
41785       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
41786     } catch (std::out_of_range& e) {
41787       {
41788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41789       };
41790     } catch (std::exception& e) {
41791       {
41792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41793       };
41794     } catch (Dali::DaliException e) {
41795       {
41796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41797       };
41798     } catch (...) {
41799       {
41800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41801       };
41802     }
41803   }
41804
41805   jresult = (void *)result;
41806   return jresult;
41807 }
41808
41809
41810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
41811   void * jresult ;
41812   Dali::PinchGesture *arg1 = 0 ;
41813   Dali::PinchGesture *result = 0 ;
41814
41815   arg1 = (Dali::PinchGesture *)jarg1;
41816   if (!arg1) {
41817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41818     return 0;
41819   }
41820   {
41821     try {
41822       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
41823     } catch (std::out_of_range& e) {
41824       {
41825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41826       };
41827     } catch (std::exception& e) {
41828       {
41829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41830       };
41831     } catch (Dali::DaliException e) {
41832       {
41833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41834       };
41835     } catch (...) {
41836       {
41837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41838       };
41839     }
41840   }
41841
41842   jresult = (void *)result;
41843   return jresult;
41844 }
41845
41846
41847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
41848   void * jresult ;
41849   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41850   Dali::PinchGesture *arg2 = 0 ;
41851   Dali::PinchGesture *result = 0 ;
41852
41853   arg1 = (Dali::PinchGesture *)jarg1;
41854   arg2 = (Dali::PinchGesture *)jarg2;
41855   if (!arg2) {
41856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41857     return 0;
41858   }
41859   {
41860     try {
41861       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
41862     } catch (std::out_of_range& e) {
41863       {
41864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41865       };
41866     } catch (std::exception& e) {
41867       {
41868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41869       };
41870     } catch (Dali::DaliException e) {
41871       {
41872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41873       };
41874     } catch (...) {
41875       {
41876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41877       };
41878     }
41879   }
41880
41881   jresult = (void *)result;
41882   return jresult;
41883 }
41884
41885
41886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
41887   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41888
41889   arg1 = (Dali::PinchGesture *)jarg1;
41890   {
41891     try {
41892       delete arg1;
41893     } catch (std::out_of_range& e) {
41894       {
41895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41896       };
41897     } catch (std::exception& e) {
41898       {
41899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41900       };
41901     } catch (Dali::DaliException e) {
41902       {
41903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41904       };
41905     } catch (...) {
41906       {
41907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41908       };
41909     }
41910   }
41911
41912 }
41913
41914
41915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
41916   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41917   float arg2 ;
41918
41919   arg1 = (Dali::PinchGesture *)jarg1;
41920   arg2 = (float)jarg2;
41921   if (arg1) (arg1)->scale = arg2;
41922 }
41923
41924
41925 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
41926   float jresult ;
41927   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41928   float result;
41929
41930   arg1 = (Dali::PinchGesture *)jarg1;
41931   result = (float) ((arg1)->scale);
41932   jresult = result;
41933   return jresult;
41934 }
41935
41936
41937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
41938   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41939   float arg2 ;
41940
41941   arg1 = (Dali::PinchGesture *)jarg1;
41942   arg2 = (float)jarg2;
41943   if (arg1) (arg1)->speed = arg2;
41944 }
41945
41946
41947 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
41948   float jresult ;
41949   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41950   float result;
41951
41952   arg1 = (Dali::PinchGesture *)jarg1;
41953   result = (float) ((arg1)->speed);
41954   jresult = result;
41955   return jresult;
41956 }
41957
41958
41959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
41960   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41961   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41962
41963   arg1 = (Dali::PinchGesture *)jarg1;
41964   arg2 = (Dali::Vector2 *)jarg2;
41965   if (arg1) (arg1)->screenCenterPoint = *arg2;
41966 }
41967
41968
41969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
41970   void * jresult ;
41971   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41972   Dali::Vector2 *result = 0 ;
41973
41974   arg1 = (Dali::PinchGesture *)jarg1;
41975   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
41976   jresult = (void *)result;
41977   return jresult;
41978 }
41979
41980
41981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
41982   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41983   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41984
41985   arg1 = (Dali::PinchGesture *)jarg1;
41986   arg2 = (Dali::Vector2 *)jarg2;
41987   if (arg1) (arg1)->localCenterPoint = *arg2;
41988 }
41989
41990
41991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
41992   void * jresult ;
41993   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41994   Dali::Vector2 *result = 0 ;
41995
41996   arg1 = (Dali::PinchGesture *)jarg1;
41997   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
41998   jresult = (void *)result;
41999   return jresult;
42000 }
42001
42002
42003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
42004   void * jresult ;
42005   Dali::TapGestureDetector *result = 0 ;
42006
42007   {
42008     try {
42009       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
42010     } catch (std::out_of_range& e) {
42011       {
42012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42013       };
42014     } catch (std::exception& e) {
42015       {
42016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42017       };
42018     } catch (Dali::DaliException e) {
42019       {
42020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42021       };
42022     } catch (...) {
42023       {
42024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42025       };
42026     }
42027   }
42028
42029   jresult = (void *)result;
42030   return jresult;
42031 }
42032
42033
42034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
42035   void * jresult ;
42036   Dali::TapGestureDetector result;
42037
42038   {
42039     try {
42040       result = Dali::TapGestureDetector::New();
42041     } catch (std::out_of_range& e) {
42042       {
42043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42044       };
42045     } catch (std::exception& e) {
42046       {
42047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42048       };
42049     } catch (Dali::DaliException e) {
42050       {
42051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42052       };
42053     } catch (...) {
42054       {
42055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42056       };
42057     }
42058   }
42059
42060   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42061   return jresult;
42062 }
42063
42064
42065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
42066   void * jresult ;
42067   unsigned int arg1 ;
42068   Dali::TapGestureDetector result;
42069
42070   arg1 = (unsigned int)jarg1;
42071   {
42072     try {
42073       result = Dali::TapGestureDetector::New(arg1);
42074     } catch (std::out_of_range& e) {
42075       {
42076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42077       };
42078     } catch (std::exception& e) {
42079       {
42080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42081       };
42082     } catch (Dali::DaliException e) {
42083       {
42084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42085       };
42086     } catch (...) {
42087       {
42088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42089       };
42090     }
42091   }
42092
42093   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42094   return jresult;
42095 }
42096
42097
42098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
42099   void * jresult ;
42100   Dali::BaseHandle arg1 ;
42101   Dali::BaseHandle *argp1 ;
42102   Dali::TapGestureDetector result;
42103
42104   argp1 = (Dali::BaseHandle *)jarg1;
42105   if (!argp1) {
42106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42107     return 0;
42108   }
42109   arg1 = *argp1;
42110   {
42111     try {
42112       result = Dali::TapGestureDetector::DownCast(arg1);
42113     } catch (std::out_of_range& e) {
42114       {
42115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42116       };
42117     } catch (std::exception& e) {
42118       {
42119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42120       };
42121     } catch (Dali::DaliException e) {
42122       {
42123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42124       };
42125     } catch (...) {
42126       {
42127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42128       };
42129     }
42130   }
42131
42132   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42133   return jresult;
42134 }
42135
42136
42137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
42138   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42139
42140   arg1 = (Dali::TapGestureDetector *)jarg1;
42141   {
42142     try {
42143       delete arg1;
42144     } catch (std::out_of_range& e) {
42145       {
42146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42147       };
42148     } catch (std::exception& e) {
42149       {
42150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42151       };
42152     } catch (Dali::DaliException e) {
42153       {
42154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42155       };
42156     } catch (...) {
42157       {
42158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42159       };
42160     }
42161   }
42162
42163 }
42164
42165
42166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
42167   void * jresult ;
42168   Dali::TapGestureDetector *arg1 = 0 ;
42169   Dali::TapGestureDetector *result = 0 ;
42170
42171   arg1 = (Dali::TapGestureDetector *)jarg1;
42172   if (!arg1) {
42173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42174     return 0;
42175   }
42176   {
42177     try {
42178       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
42179     } catch (std::out_of_range& e) {
42180       {
42181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42182       };
42183     } catch (std::exception& e) {
42184       {
42185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42186       };
42187     } catch (Dali::DaliException e) {
42188       {
42189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42190       };
42191     } catch (...) {
42192       {
42193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42194       };
42195     }
42196   }
42197
42198   jresult = (void *)result;
42199   return jresult;
42200 }
42201
42202
42203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
42204   void * jresult ;
42205   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42206   Dali::TapGestureDetector *arg2 = 0 ;
42207   Dali::TapGestureDetector *result = 0 ;
42208
42209   arg1 = (Dali::TapGestureDetector *)jarg1;
42210   arg2 = (Dali::TapGestureDetector *)jarg2;
42211   if (!arg2) {
42212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42213     return 0;
42214   }
42215   {
42216     try {
42217       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
42218     } catch (std::out_of_range& e) {
42219       {
42220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42221       };
42222     } catch (std::exception& e) {
42223       {
42224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42225       };
42226     } catch (Dali::DaliException e) {
42227       {
42228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42229       };
42230     } catch (...) {
42231       {
42232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42233       };
42234     }
42235   }
42236
42237   jresult = (void *)result;
42238   return jresult;
42239 }
42240
42241
42242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
42243   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42244   unsigned int arg2 ;
42245
42246   arg1 = (Dali::TapGestureDetector *)jarg1;
42247   arg2 = (unsigned int)jarg2;
42248   {
42249     try {
42250       (arg1)->SetMinimumTapsRequired(arg2);
42251     } catch (std::out_of_range& e) {
42252       {
42253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42254       };
42255     } catch (std::exception& e) {
42256       {
42257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42258       };
42259     } catch (Dali::DaliException e) {
42260       {
42261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42262       };
42263     } catch (...) {
42264       {
42265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42266       };
42267     }
42268   }
42269
42270 }
42271
42272
42273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
42274   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42275   unsigned int arg2 ;
42276
42277   arg1 = (Dali::TapGestureDetector *)jarg1;
42278   arg2 = (unsigned int)jarg2;
42279   {
42280     try {
42281       (arg1)->SetMaximumTapsRequired(arg2);
42282     } catch (std::out_of_range& e) {
42283       {
42284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42285       };
42286     } catch (std::exception& e) {
42287       {
42288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42289       };
42290     } catch (Dali::DaliException e) {
42291       {
42292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42293       };
42294     } catch (...) {
42295       {
42296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42297       };
42298     }
42299   }
42300
42301 }
42302
42303
42304 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
42305   unsigned int jresult ;
42306   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42307   unsigned int result;
42308
42309   arg1 = (Dali::TapGestureDetector *)jarg1;
42310   {
42311     try {
42312       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
42313     } catch (std::out_of_range& e) {
42314       {
42315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42316       };
42317     } catch (std::exception& e) {
42318       {
42319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42320       };
42321     } catch (Dali::DaliException e) {
42322       {
42323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42324       };
42325     } catch (...) {
42326       {
42327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42328       };
42329     }
42330   }
42331
42332   jresult = result;
42333   return jresult;
42334 }
42335
42336
42337 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
42338   unsigned int jresult ;
42339   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42340   unsigned int result;
42341
42342   arg1 = (Dali::TapGestureDetector *)jarg1;
42343   {
42344     try {
42345       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
42346     } catch (std::out_of_range& e) {
42347       {
42348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42349       };
42350     } catch (std::exception& e) {
42351       {
42352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42353       };
42354     } catch (Dali::DaliException e) {
42355       {
42356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42357       };
42358     } catch (...) {
42359       {
42360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42361       };
42362     }
42363   }
42364
42365   jresult = result;
42366   return jresult;
42367 }
42368
42369
42370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
42371   void * jresult ;
42372   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42373   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
42374
42375   arg1 = (Dali::TapGestureDetector *)jarg1;
42376   {
42377     try {
42378       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42379     } catch (std::out_of_range& e) {
42380       {
42381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42382       };
42383     } catch (std::exception& e) {
42384       {
42385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42386       };
42387     } catch (Dali::DaliException e) {
42388       {
42389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42390       };
42391     } catch (...) {
42392       {
42393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42394       };
42395     }
42396   }
42397
42398   jresult = (void *)result;
42399   return jresult;
42400 }
42401
42402
42403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
42404   void * jresult ;
42405   Dali::TapGesture *result = 0 ;
42406
42407   {
42408     try {
42409       result = (Dali::TapGesture *)new Dali::TapGesture();
42410     } catch (std::out_of_range& e) {
42411       {
42412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42413       };
42414     } catch (std::exception& e) {
42415       {
42416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42417       };
42418     } catch (Dali::DaliException e) {
42419       {
42420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42421       };
42422     } catch (...) {
42423       {
42424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42425       };
42426     }
42427   }
42428
42429   jresult = (void *)result;
42430   return jresult;
42431 }
42432
42433
42434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
42435   void * jresult ;
42436   Dali::TapGesture *arg1 = 0 ;
42437   Dali::TapGesture *result = 0 ;
42438
42439   arg1 = (Dali::TapGesture *)jarg1;
42440   if (!arg1) {
42441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42442     return 0;
42443   }
42444   {
42445     try {
42446       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
42447     } catch (std::out_of_range& e) {
42448       {
42449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42450       };
42451     } catch (std::exception& e) {
42452       {
42453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42454       };
42455     } catch (Dali::DaliException e) {
42456       {
42457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42458       };
42459     } catch (...) {
42460       {
42461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42462       };
42463     }
42464   }
42465
42466   jresult = (void *)result;
42467   return jresult;
42468 }
42469
42470
42471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
42472   void * jresult ;
42473   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42474   Dali::TapGesture *arg2 = 0 ;
42475   Dali::TapGesture *result = 0 ;
42476
42477   arg1 = (Dali::TapGesture *)jarg1;
42478   arg2 = (Dali::TapGesture *)jarg2;
42479   if (!arg2) {
42480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42481     return 0;
42482   }
42483   {
42484     try {
42485       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
42486     } catch (std::out_of_range& e) {
42487       {
42488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42489       };
42490     } catch (std::exception& e) {
42491       {
42492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42493       };
42494     } catch (Dali::DaliException e) {
42495       {
42496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42497       };
42498     } catch (...) {
42499       {
42500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42501       };
42502     }
42503   }
42504
42505   jresult = (void *)result;
42506   return jresult;
42507 }
42508
42509
42510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
42511   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42512
42513   arg1 = (Dali::TapGesture *)jarg1;
42514   {
42515     try {
42516       delete arg1;
42517     } catch (std::out_of_range& e) {
42518       {
42519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42520       };
42521     } catch (std::exception& e) {
42522       {
42523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42524       };
42525     } catch (Dali::DaliException e) {
42526       {
42527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42528       };
42529     } catch (...) {
42530       {
42531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42532       };
42533     }
42534   }
42535
42536 }
42537
42538
42539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
42540   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42541   unsigned int arg2 ;
42542
42543   arg1 = (Dali::TapGesture *)jarg1;
42544   arg2 = (unsigned int)jarg2;
42545   if (arg1) (arg1)->numberOfTaps = arg2;
42546 }
42547
42548
42549 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
42550   unsigned int jresult ;
42551   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42552   unsigned int result;
42553
42554   arg1 = (Dali::TapGesture *)jarg1;
42555   result = (unsigned int) ((arg1)->numberOfTaps);
42556   jresult = result;
42557   return jresult;
42558 }
42559
42560
42561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
42562   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42563   unsigned int arg2 ;
42564
42565   arg1 = (Dali::TapGesture *)jarg1;
42566   arg2 = (unsigned int)jarg2;
42567   if (arg1) (arg1)->numberOfTouches = arg2;
42568 }
42569
42570
42571 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
42572   unsigned int jresult ;
42573   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42574   unsigned int result;
42575
42576   arg1 = (Dali::TapGesture *)jarg1;
42577   result = (unsigned int) ((arg1)->numberOfTouches);
42578   jresult = result;
42579   return jresult;
42580 }
42581
42582
42583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
42584   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42585   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42586
42587   arg1 = (Dali::TapGesture *)jarg1;
42588   arg2 = (Dali::Vector2 *)jarg2;
42589   if (arg1) (arg1)->screenPoint = *arg2;
42590 }
42591
42592
42593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42594   void * jresult ;
42595   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42596   Dali::Vector2 *result = 0 ;
42597
42598   arg1 = (Dali::TapGesture *)jarg1;
42599   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42600   jresult = (void *)result;
42601   return jresult;
42602 }
42603
42604
42605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42606   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42607   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42608
42609   arg1 = (Dali::TapGesture *)jarg1;
42610   arg2 = (Dali::Vector2 *)jarg2;
42611   if (arg1) (arg1)->localPoint = *arg2;
42612 }
42613
42614
42615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42616   void * jresult ;
42617   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42618   Dali::Vector2 *result = 0 ;
42619
42620   arg1 = (Dali::TapGesture *)jarg1;
42621   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42622   jresult = (void *)result;
42623   return jresult;
42624 }
42625
42626
42627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42628   void * jresult ;
42629   Dali::AlphaFunction *result = 0 ;
42630
42631   {
42632     try {
42633       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42634     } catch (std::out_of_range& e) {
42635       {
42636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42637       };
42638     } catch (std::exception& e) {
42639       {
42640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42641       };
42642     } catch (Dali::DaliException e) {
42643       {
42644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42645       };
42646     } catch (...) {
42647       {
42648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42649       };
42650     }
42651   }
42652
42653   jresult = (void *)result;
42654   return jresult;
42655 }
42656
42657
42658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
42659   void * jresult ;
42660   Dali::AlphaFunction::BuiltinFunction arg1 ;
42661   Dali::AlphaFunction *result = 0 ;
42662
42663   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
42664   {
42665     try {
42666       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42667     } catch (std::out_of_range& e) {
42668       {
42669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42670       };
42671     } catch (std::exception& e) {
42672       {
42673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42674       };
42675     } catch (Dali::DaliException e) {
42676       {
42677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42678       };
42679     } catch (...) {
42680       {
42681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42682       };
42683     }
42684   }
42685
42686   jresult = (void *)result;
42687   return jresult;
42688 }
42689
42690
42691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
42692   void * jresult ;
42693   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
42694   Dali::AlphaFunction *result = 0 ;
42695
42696   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
42697   {
42698     try {
42699       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42700     } catch (std::out_of_range& e) {
42701       {
42702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42703       };
42704     } catch (std::exception& e) {
42705       {
42706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42707       };
42708     } catch (Dali::DaliException e) {
42709       {
42710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42711       };
42712     } catch (...) {
42713       {
42714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42715       };
42716     }
42717   }
42718
42719   jresult = (void *)result;
42720   return jresult;
42721 }
42722
42723
42724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
42725   void * jresult ;
42726   Dali::Vector2 *arg1 = 0 ;
42727   Dali::Vector2 *arg2 = 0 ;
42728   Dali::AlphaFunction *result = 0 ;
42729
42730   arg1 = (Dali::Vector2 *)jarg1;
42731   if (!arg1) {
42732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42733     return 0;
42734   }
42735   arg2 = (Dali::Vector2 *)jarg2;
42736   if (!arg2) {
42737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42738     return 0;
42739   }
42740   {
42741     try {
42742       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
42743     } catch (std::out_of_range& e) {
42744       {
42745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42746       };
42747     } catch (std::exception& e) {
42748       {
42749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42750       };
42751     } catch (Dali::DaliException e) {
42752       {
42753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42754       };
42755     } catch (...) {
42756       {
42757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42758       };
42759     }
42760   }
42761
42762   jresult = (void *)result;
42763   return jresult;
42764 }
42765
42766
42767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
42768   void * jresult ;
42769   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42770   Dali::Vector4 result;
42771
42772   arg1 = (Dali::AlphaFunction *)jarg1;
42773   {
42774     try {
42775       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
42776     } catch (std::out_of_range& e) {
42777       {
42778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42779       };
42780     } catch (std::exception& e) {
42781       {
42782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42783       };
42784     } catch (Dali::DaliException e) {
42785       {
42786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42787       };
42788     } catch (...) {
42789       {
42790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42791       };
42792     }
42793   }
42794
42795   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
42796   return jresult;
42797 }
42798
42799
42800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
42801   void * jresult ;
42802   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42803   Dali::AlphaFunctionPrototype result;
42804
42805   arg1 = (Dali::AlphaFunction *)jarg1;
42806   {
42807     try {
42808       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
42809     } catch (std::out_of_range& e) {
42810       {
42811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42812       };
42813     } catch (std::exception& e) {
42814       {
42815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42816       };
42817     } catch (Dali::DaliException e) {
42818       {
42819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42820       };
42821     } catch (...) {
42822       {
42823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42824       };
42825     }
42826   }
42827
42828   jresult = (void *)result;
42829   return jresult;
42830 }
42831
42832
42833 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
42834   int jresult ;
42835   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42836   Dali::AlphaFunction::BuiltinFunction result;
42837
42838   arg1 = (Dali::AlphaFunction *)jarg1;
42839   {
42840     try {
42841       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
42842     } catch (std::out_of_range& e) {
42843       {
42844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42845       };
42846     } catch (std::exception& e) {
42847       {
42848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42849       };
42850     } catch (Dali::DaliException e) {
42851       {
42852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42853       };
42854     } catch (...) {
42855       {
42856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42857       };
42858     }
42859   }
42860
42861   jresult = (int)result;
42862   return jresult;
42863 }
42864
42865
42866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
42867   int jresult ;
42868   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42869   Dali::AlphaFunction::Mode result;
42870
42871   arg1 = (Dali::AlphaFunction *)jarg1;
42872   {
42873     try {
42874       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
42875     } catch (std::out_of_range& e) {
42876       {
42877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42878       };
42879     } catch (std::exception& e) {
42880       {
42881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42882       };
42883     } catch (Dali::DaliException e) {
42884       {
42885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42886       };
42887     } catch (...) {
42888       {
42889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42890       };
42891     }
42892   }
42893
42894   jresult = (int)result;
42895   return jresult;
42896 }
42897
42898
42899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
42900   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42901
42902   arg1 = (Dali::AlphaFunction *)jarg1;
42903   {
42904     try {
42905       delete arg1;
42906     } catch (std::out_of_range& e) {
42907       {
42908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42909       };
42910     } catch (std::exception& e) {
42911       {
42912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42913       };
42914     } catch (Dali::DaliException e) {
42915       {
42916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42917       };
42918     } catch (...) {
42919       {
42920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42921       };
42922     }
42923   }
42924
42925 }
42926
42927
42928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
42929   void * jresult ;
42930   Dali::KeyFrames result;
42931
42932   {
42933     try {
42934       result = Dali::KeyFrames::New();
42935     } catch (std::out_of_range& e) {
42936       {
42937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42938       };
42939     } catch (std::exception& e) {
42940       {
42941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42942       };
42943     } catch (Dali::DaliException e) {
42944       {
42945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42946       };
42947     } catch (...) {
42948       {
42949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42950       };
42951     }
42952   }
42953
42954   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
42955   return jresult;
42956 }
42957
42958
42959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
42960   void * jresult ;
42961   Dali::BaseHandle arg1 ;
42962   Dali::BaseHandle *argp1 ;
42963   Dali::KeyFrames result;
42964
42965   argp1 = (Dali::BaseHandle *)jarg1;
42966   if (!argp1) {
42967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42968     return 0;
42969   }
42970   arg1 = *argp1;
42971   {
42972     try {
42973       result = Dali::KeyFrames::DownCast(arg1);
42974     } catch (std::out_of_range& e) {
42975       {
42976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42977       };
42978     } catch (std::exception& e) {
42979       {
42980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42981       };
42982     } catch (Dali::DaliException e) {
42983       {
42984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42985       };
42986     } catch (...) {
42987       {
42988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42989       };
42990     }
42991   }
42992
42993   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
42994   return jresult;
42995 }
42996
42997
42998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
42999   void * jresult ;
43000   Dali::KeyFrames *result = 0 ;
43001
43002   {
43003     try {
43004       result = (Dali::KeyFrames *)new Dali::KeyFrames();
43005     } catch (std::out_of_range& e) {
43006       {
43007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43008       };
43009     } catch (std::exception& e) {
43010       {
43011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43012       };
43013     } catch (Dali::DaliException e) {
43014       {
43015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43016       };
43017     } catch (...) {
43018       {
43019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43020       };
43021     }
43022   }
43023
43024   jresult = (void *)result;
43025   return jresult;
43026 }
43027
43028
43029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
43030   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43031
43032   arg1 = (Dali::KeyFrames *)jarg1;
43033   {
43034     try {
43035       delete arg1;
43036     } catch (std::out_of_range& e) {
43037       {
43038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43039       };
43040     } catch (std::exception& e) {
43041       {
43042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43043       };
43044     } catch (Dali::DaliException e) {
43045       {
43046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43047       };
43048     } catch (...) {
43049       {
43050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43051       };
43052     }
43053   }
43054
43055 }
43056
43057
43058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
43059   void * jresult ;
43060   Dali::KeyFrames *arg1 = 0 ;
43061   Dali::KeyFrames *result = 0 ;
43062
43063   arg1 = (Dali::KeyFrames *)jarg1;
43064   if (!arg1) {
43065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43066     return 0;
43067   }
43068   {
43069     try {
43070       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
43071     } catch (std::out_of_range& e) {
43072       {
43073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43074       };
43075     } catch (std::exception& e) {
43076       {
43077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43078       };
43079     } catch (Dali::DaliException e) {
43080       {
43081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43082       };
43083     } catch (...) {
43084       {
43085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43086       };
43087     }
43088   }
43089
43090   jresult = (void *)result;
43091   return jresult;
43092 }
43093
43094
43095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
43096   void * jresult ;
43097   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43098   Dali::KeyFrames *arg2 = 0 ;
43099   Dali::KeyFrames *result = 0 ;
43100
43101   arg1 = (Dali::KeyFrames *)jarg1;
43102   arg2 = (Dali::KeyFrames *)jarg2;
43103   if (!arg2) {
43104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43105     return 0;
43106   }
43107   {
43108     try {
43109       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
43110     } catch (std::out_of_range& e) {
43111       {
43112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43113       };
43114     } catch (std::exception& e) {
43115       {
43116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43117       };
43118     } catch (Dali::DaliException e) {
43119       {
43120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43121       };
43122     } catch (...) {
43123       {
43124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43125       };
43126     }
43127   }
43128
43129   jresult = (void *)result;
43130   return jresult;
43131 }
43132
43133
43134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
43135   int jresult ;
43136   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43137   Dali::Property::Type result;
43138
43139   arg1 = (Dali::KeyFrames *)jarg1;
43140   {
43141     try {
43142       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
43143     } catch (std::out_of_range& e) {
43144       {
43145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43146       };
43147     } catch (std::exception& e) {
43148       {
43149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43150       };
43151     } catch (Dali::DaliException e) {
43152       {
43153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43154       };
43155     } catch (...) {
43156       {
43157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43158       };
43159     }
43160   }
43161
43162   jresult = (int)result;
43163   return jresult;
43164 }
43165
43166
43167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
43168   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43169   float arg2 ;
43170   Dali::Property::Value arg3 ;
43171   Dali::Property::Value *argp3 ;
43172
43173   arg1 = (Dali::KeyFrames *)jarg1;
43174   arg2 = (float)jarg2;
43175   argp3 = (Dali::Property::Value *)jarg3;
43176   if (!argp3) {
43177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43178     return ;
43179   }
43180   arg3 = *argp3;
43181   {
43182     try {
43183       (arg1)->Add(arg2,arg3);
43184     } catch (std::out_of_range& e) {
43185       {
43186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43187       };
43188     } catch (std::exception& e) {
43189       {
43190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43191       };
43192     } catch (Dali::DaliException e) {
43193       {
43194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43195       };
43196     } catch (...) {
43197       {
43198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43199       };
43200     }
43201   }
43202
43203 }
43204
43205
43206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43207   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43208   float arg2 ;
43209   Dali::Property::Value arg3 ;
43210   Dali::AlphaFunction arg4 ;
43211   Dali::Property::Value *argp3 ;
43212   Dali::AlphaFunction *argp4 ;
43213
43214   arg1 = (Dali::KeyFrames *)jarg1;
43215   arg2 = (float)jarg2;
43216   argp3 = (Dali::Property::Value *)jarg3;
43217   if (!argp3) {
43218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43219     return ;
43220   }
43221   arg3 = *argp3;
43222   argp4 = (Dali::AlphaFunction *)jarg4;
43223   if (!argp4) {
43224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
43225     return ;
43226   }
43227   arg4 = *argp4;
43228   {
43229     try {
43230       (arg1)->Add(arg2,arg3,arg4);
43231     } catch (std::out_of_range& e) {
43232       {
43233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43234       };
43235     } catch (std::exception& e) {
43236       {
43237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43238       };
43239     } catch (Dali::DaliException e) {
43240       {
43241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43242       };
43243     } catch (...) {
43244       {
43245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43246       };
43247     }
43248   }
43249
43250 }
43251
43252
43253 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
43254   int jresult ;
43255   int result;
43256
43257   result = (int)Dali::Path::Property::POINTS;
43258   jresult = (int)result;
43259   return jresult;
43260 }
43261
43262
43263 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
43264   int jresult ;
43265   int result;
43266
43267   result = (int)Dali::Path::Property::CONTROL_POINTS;
43268   jresult = (int)result;
43269   return jresult;
43270 }
43271
43272
43273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
43274   void * jresult ;
43275   Dali::Path::Property *result = 0 ;
43276
43277   {
43278     try {
43279       result = (Dali::Path::Property *)new Dali::Path::Property();
43280     } catch (std::out_of_range& e) {
43281       {
43282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43283       };
43284     } catch (std::exception& e) {
43285       {
43286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43287       };
43288     } catch (Dali::DaliException e) {
43289       {
43290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43291       };
43292     } catch (...) {
43293       {
43294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43295       };
43296     }
43297   }
43298
43299   jresult = (void *)result;
43300   return jresult;
43301 }
43302
43303
43304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
43305   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
43306
43307   arg1 = (Dali::Path::Property *)jarg1;
43308   {
43309     try {
43310       delete arg1;
43311     } catch (std::out_of_range& e) {
43312       {
43313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43314       };
43315     } catch (std::exception& e) {
43316       {
43317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43318       };
43319     } catch (Dali::DaliException e) {
43320       {
43321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43322       };
43323     } catch (...) {
43324       {
43325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43326       };
43327     }
43328   }
43329
43330 }
43331
43332
43333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
43334   void * jresult ;
43335   Dali::Path result;
43336
43337   {
43338     try {
43339       result = Dali::Path::New();
43340     } catch (std::out_of_range& e) {
43341       {
43342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43343       };
43344     } catch (std::exception& e) {
43345       {
43346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43347       };
43348     } catch (Dali::DaliException e) {
43349       {
43350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43351       };
43352     } catch (...) {
43353       {
43354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43355       };
43356     }
43357   }
43358
43359   jresult = new Dali::Path((const Dali::Path &)result);
43360   return jresult;
43361 }
43362
43363
43364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
43365   void * jresult ;
43366   Dali::BaseHandle arg1 ;
43367   Dali::BaseHandle *argp1 ;
43368   Dali::Path result;
43369
43370   argp1 = (Dali::BaseHandle *)jarg1;
43371   if (!argp1) {
43372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43373     return 0;
43374   }
43375   arg1 = *argp1;
43376   {
43377     try {
43378       result = Dali::Path::DownCast(arg1);
43379     } catch (std::out_of_range& e) {
43380       {
43381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43382       };
43383     } catch (std::exception& e) {
43384       {
43385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43386       };
43387     } catch (Dali::DaliException e) {
43388       {
43389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43390       };
43391     } catch (...) {
43392       {
43393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43394       };
43395     }
43396   }
43397
43398   jresult = new Dali::Path((const Dali::Path &)result);
43399   return jresult;
43400 }
43401
43402
43403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
43404   void * jresult ;
43405   Dali::Path *result = 0 ;
43406
43407   {
43408     try {
43409       result = (Dali::Path *)new Dali::Path();
43410     } catch (std::out_of_range& e) {
43411       {
43412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43413       };
43414     } catch (std::exception& e) {
43415       {
43416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43417       };
43418     } catch (Dali::DaliException e) {
43419       {
43420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43421       };
43422     } catch (...) {
43423       {
43424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43425       };
43426     }
43427   }
43428
43429   jresult = (void *)result;
43430   return jresult;
43431 }
43432
43433
43434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
43435   Dali::Path *arg1 = (Dali::Path *) 0 ;
43436
43437   arg1 = (Dali::Path *)jarg1;
43438   {
43439     try {
43440       delete arg1;
43441     } catch (std::out_of_range& e) {
43442       {
43443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43444       };
43445     } catch (std::exception& e) {
43446       {
43447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43448       };
43449     } catch (Dali::DaliException e) {
43450       {
43451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43452       };
43453     } catch (...) {
43454       {
43455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43456       };
43457     }
43458   }
43459
43460 }
43461
43462
43463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
43464   void * jresult ;
43465   Dali::Path *arg1 = 0 ;
43466   Dali::Path *result = 0 ;
43467
43468   arg1 = (Dali::Path *)jarg1;
43469   if (!arg1) {
43470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43471     return 0;
43472   }
43473   {
43474     try {
43475       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
43476     } catch (std::out_of_range& e) {
43477       {
43478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43479       };
43480     } catch (std::exception& e) {
43481       {
43482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43483       };
43484     } catch (Dali::DaliException e) {
43485       {
43486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43487       };
43488     } catch (...) {
43489       {
43490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43491       };
43492     }
43493   }
43494
43495   jresult = (void *)result;
43496   return jresult;
43497 }
43498
43499
43500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
43501   void * jresult ;
43502   Dali::Path *arg1 = (Dali::Path *) 0 ;
43503   Dali::Path *arg2 = 0 ;
43504   Dali::Path *result = 0 ;
43505
43506   arg1 = (Dali::Path *)jarg1;
43507   arg2 = (Dali::Path *)jarg2;
43508   if (!arg2) {
43509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43510     return 0;
43511   }
43512   {
43513     try {
43514       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
43515     } catch (std::out_of_range& e) {
43516       {
43517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43518       };
43519     } catch (std::exception& e) {
43520       {
43521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43522       };
43523     } catch (Dali::DaliException e) {
43524       {
43525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43526       };
43527     } catch (...) {
43528       {
43529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43530       };
43531     }
43532   }
43533
43534   jresult = (void *)result;
43535   return jresult;
43536 }
43537
43538
43539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
43540   Dali::Path *arg1 = (Dali::Path *) 0 ;
43541   Dali::Vector3 *arg2 = 0 ;
43542
43543   arg1 = (Dali::Path *)jarg1;
43544   arg2 = (Dali::Vector3 *)jarg2;
43545   if (!arg2) {
43546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43547     return ;
43548   }
43549   {
43550     try {
43551       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
43552     } catch (std::out_of_range& e) {
43553       {
43554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43555       };
43556     } catch (std::exception& e) {
43557       {
43558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43559       };
43560     } catch (Dali::DaliException e) {
43561       {
43562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43563       };
43564     } catch (...) {
43565       {
43566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43567       };
43568     }
43569   }
43570
43571 }
43572
43573
43574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
43575   Dali::Path *arg1 = (Dali::Path *) 0 ;
43576   Dali::Vector3 *arg2 = 0 ;
43577
43578   arg1 = (Dali::Path *)jarg1;
43579   arg2 = (Dali::Vector3 *)jarg2;
43580   if (!arg2) {
43581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43582     return ;
43583   }
43584   {
43585     try {
43586       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
43587     } catch (std::out_of_range& e) {
43588       {
43589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43590       };
43591     } catch (std::exception& e) {
43592       {
43593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43594       };
43595     } catch (Dali::DaliException e) {
43596       {
43597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43598       };
43599     } catch (...) {
43600       {
43601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43602       };
43603     }
43604   }
43605
43606 }
43607
43608
43609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43610   Dali::Path *arg1 = (Dali::Path *) 0 ;
43611   float arg2 ;
43612
43613   arg1 = (Dali::Path *)jarg1;
43614   arg2 = (float)jarg2;
43615   {
43616     try {
43617       (arg1)->GenerateControlPoints(arg2);
43618     } catch (std::out_of_range& e) {
43619       {
43620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43621       };
43622     } catch (std::exception& e) {
43623       {
43624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43625       };
43626     } catch (Dali::DaliException e) {
43627       {
43628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43629       };
43630     } catch (...) {
43631       {
43632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43633       };
43634     }
43635   }
43636
43637 }
43638
43639
43640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43641   Dali::Path *arg1 = (Dali::Path *) 0 ;
43642   float arg2 ;
43643   Dali::Vector3 *arg3 = 0 ;
43644   Dali::Vector3 *arg4 = 0 ;
43645
43646   arg1 = (Dali::Path *)jarg1;
43647   arg2 = (float)jarg2;
43648   arg3 = (Dali::Vector3 *)jarg3;
43649   if (!arg3) {
43650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43651     return ;
43652   }
43653   arg4 = (Dali::Vector3 *)jarg4;
43654   if (!arg4) {
43655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43656     return ;
43657   }
43658   {
43659     try {
43660       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
43661     } catch (std::out_of_range& e) {
43662       {
43663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43664       };
43665     } catch (std::exception& e) {
43666       {
43667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43668       };
43669     } catch (Dali::DaliException e) {
43670       {
43671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43672       };
43673     } catch (...) {
43674       {
43675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43676       };
43677     }
43678   }
43679
43680 }
43681
43682
43683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
43684   void * jresult ;
43685   Dali::Path *arg1 = (Dali::Path *) 0 ;
43686   size_t arg2 ;
43687   Dali::Vector3 *result = 0 ;
43688
43689   arg1 = (Dali::Path *)jarg1;
43690   arg2 = (size_t)jarg2;
43691   {
43692     try {
43693       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
43694     } catch (std::out_of_range& e) {
43695       {
43696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43697       };
43698     } catch (std::exception& e) {
43699       {
43700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43701       };
43702     } catch (Dali::DaliException e) {
43703       {
43704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43705       };
43706     } catch (...) {
43707       {
43708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43709       };
43710     }
43711   }
43712
43713   jresult = (void *)result;
43714   return jresult;
43715 }
43716
43717
43718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
43719   void * jresult ;
43720   Dali::Path *arg1 = (Dali::Path *) 0 ;
43721   size_t arg2 ;
43722   Dali::Vector3 *result = 0 ;
43723
43724   arg1 = (Dali::Path *)jarg1;
43725   arg2 = (size_t)jarg2;
43726   {
43727     try {
43728       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
43729     } catch (std::out_of_range& e) {
43730       {
43731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43732       };
43733     } catch (std::exception& e) {
43734       {
43735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43736       };
43737     } catch (Dali::DaliException e) {
43738       {
43739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43740       };
43741     } catch (...) {
43742       {
43743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43744       };
43745     }
43746   }
43747
43748   jresult = (void *)result;
43749   return jresult;
43750 }
43751
43752
43753 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
43754   unsigned long jresult ;
43755   Dali::Path *arg1 = (Dali::Path *) 0 ;
43756   size_t result;
43757
43758   arg1 = (Dali::Path *)jarg1;
43759   {
43760     try {
43761       result = ((Dali::Path const *)arg1)->GetPointCount();
43762     } catch (std::out_of_range& e) {
43763       {
43764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43765       };
43766     } catch (std::exception& e) {
43767       {
43768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43769       };
43770     } catch (Dali::DaliException e) {
43771       {
43772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43773       };
43774     } catch (...) {
43775       {
43776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43777       };
43778     }
43779   }
43780
43781   jresult = (unsigned long)result;
43782   return jresult;
43783 }
43784
43785
43786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
43787   void * jresult ;
43788   float arg1 ;
43789   Dali::TimePeriod *result = 0 ;
43790
43791   arg1 = (float)jarg1;
43792   {
43793     try {
43794       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
43795     } catch (std::out_of_range& e) {
43796       {
43797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43798       };
43799     } catch (std::exception& e) {
43800       {
43801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43802       };
43803     } catch (Dali::DaliException e) {
43804       {
43805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43806       };
43807     } catch (...) {
43808       {
43809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43810       };
43811     }
43812   }
43813
43814   jresult = (void *)result;
43815   return jresult;
43816 }
43817
43818
43819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
43820   void * jresult ;
43821   float arg1 ;
43822   float arg2 ;
43823   Dali::TimePeriod *result = 0 ;
43824
43825   arg1 = (float)jarg1;
43826   arg2 = (float)jarg2;
43827   {
43828     try {
43829       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
43830     } catch (std::out_of_range& e) {
43831       {
43832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43833       };
43834     } catch (std::exception& e) {
43835       {
43836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43837       };
43838     } catch (Dali::DaliException e) {
43839       {
43840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43841       };
43842     } catch (...) {
43843       {
43844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43845       };
43846     }
43847   }
43848
43849   jresult = (void *)result;
43850   return jresult;
43851 }
43852
43853
43854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
43855   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43856
43857   arg1 = (Dali::TimePeriod *)jarg1;
43858   {
43859     try {
43860       delete arg1;
43861     } catch (std::out_of_range& e) {
43862       {
43863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43864       };
43865     } catch (std::exception& e) {
43866       {
43867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43868       };
43869     } catch (Dali::DaliException e) {
43870       {
43871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43872       };
43873     } catch (...) {
43874       {
43875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43876       };
43877     }
43878   }
43879
43880 }
43881
43882
43883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
43884   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43885   float arg2 ;
43886
43887   arg1 = (Dali::TimePeriod *)jarg1;
43888   arg2 = (float)jarg2;
43889   if (arg1) (arg1)->delaySeconds = arg2;
43890 }
43891
43892
43893 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
43894   float jresult ;
43895   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43896   float result;
43897
43898   arg1 = (Dali::TimePeriod *)jarg1;
43899   result = (float) ((arg1)->delaySeconds);
43900   jresult = result;
43901   return jresult;
43902 }
43903
43904
43905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
43906   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43907   float arg2 ;
43908
43909   arg1 = (Dali::TimePeriod *)jarg1;
43910   arg2 = (float)jarg2;
43911   if (arg1) (arg1)->durationSeconds = arg2;
43912 }
43913
43914
43915 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
43916   float jresult ;
43917   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43918   float result;
43919
43920   arg1 = (Dali::TimePeriod *)jarg1;
43921   result = (float) ((arg1)->durationSeconds);
43922   jresult = result;
43923   return jresult;
43924 }
43925
43926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
43927   int jresult ;
43928   int result;
43929
43930   result = (int)Dali::LinearConstrainer::Property::VALUE;
43931   jresult = (int)result;
43932   return jresult;
43933 }
43934
43935
43936 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
43937   int jresult ;
43938   int result;
43939
43940   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
43941   jresult = (int)result;
43942   return jresult;
43943 }
43944
43945
43946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
43947   void * jresult ;
43948   Dali::LinearConstrainer::Property *result = 0 ;
43949
43950   {
43951     try {
43952       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
43953     } catch (std::out_of_range& e) {
43954       {
43955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43956       };
43957     } catch (std::exception& e) {
43958       {
43959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43960       };
43961     } catch (Dali::DaliException e) {
43962       {
43963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43964       };
43965     } catch (...) {
43966       {
43967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43968       };
43969     }
43970   }
43971
43972   jresult = (void *)result;
43973   return jresult;
43974 }
43975
43976
43977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
43978   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
43979
43980   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
43981   {
43982     try {
43983       delete arg1;
43984     } catch (std::out_of_range& e) {
43985       {
43986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43987       };
43988     } catch (std::exception& e) {
43989       {
43990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43991       };
43992     } catch (Dali::DaliException e) {
43993       {
43994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43995       };
43996     } catch (...) {
43997       {
43998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43999       };
44000     }
44001   }
44002
44003 }
44004
44005
44006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
44007   void * jresult ;
44008   Dali::LinearConstrainer result;
44009
44010   {
44011     try {
44012       result = Dali::LinearConstrainer::New();
44013     } catch (std::out_of_range& e) {
44014       {
44015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44016       };
44017     } catch (std::exception& e) {
44018       {
44019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44020       };
44021     } catch (Dali::DaliException e) {
44022       {
44023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44024       };
44025     } catch (...) {
44026       {
44027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44028       };
44029     }
44030   }
44031
44032   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44033   return jresult;
44034 }
44035
44036
44037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
44038   void * jresult ;
44039   Dali::BaseHandle arg1 ;
44040   Dali::BaseHandle *argp1 ;
44041   Dali::LinearConstrainer result;
44042
44043   argp1 = (Dali::BaseHandle *)jarg1;
44044   if (!argp1) {
44045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44046     return 0;
44047   }
44048   arg1 = *argp1;
44049   {
44050     try {
44051       result = Dali::LinearConstrainer::DownCast(arg1);
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 = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44072   return jresult;
44073 }
44074
44075
44076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
44077   void * jresult ;
44078   Dali::LinearConstrainer *result = 0 ;
44079
44080   {
44081     try {
44082       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
44083     } catch (std::out_of_range& e) {
44084       {
44085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44086       };
44087     } catch (std::exception& e) {
44088       {
44089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44090       };
44091     } catch (Dali::DaliException e) {
44092       {
44093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44094       };
44095     } catch (...) {
44096       {
44097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44098       };
44099     }
44100   }
44101
44102   jresult = (void *)result;
44103   return jresult;
44104 }
44105
44106
44107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
44108   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44109
44110   arg1 = (Dali::LinearConstrainer *)jarg1;
44111   {
44112     try {
44113       delete arg1;
44114     } catch (std::out_of_range& e) {
44115       {
44116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44117       };
44118     } catch (std::exception& e) {
44119       {
44120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44121       };
44122     } catch (Dali::DaliException e) {
44123       {
44124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44125       };
44126     } catch (...) {
44127       {
44128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44129       };
44130     }
44131   }
44132
44133 }
44134
44135
44136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
44137   void * jresult ;
44138   Dali::LinearConstrainer *arg1 = 0 ;
44139   Dali::LinearConstrainer *result = 0 ;
44140
44141   arg1 = (Dali::LinearConstrainer *)jarg1;
44142   if (!arg1) {
44143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44144     return 0;
44145   }
44146   {
44147     try {
44148       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
44149     } catch (std::out_of_range& e) {
44150       {
44151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44152       };
44153     } catch (std::exception& e) {
44154       {
44155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44156       };
44157     } catch (Dali::DaliException e) {
44158       {
44159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44160       };
44161     } catch (...) {
44162       {
44163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44164       };
44165     }
44166   }
44167
44168   jresult = (void *)result;
44169   return jresult;
44170 }
44171
44172
44173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
44174   void * jresult ;
44175   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44176   Dali::LinearConstrainer *arg2 = 0 ;
44177   Dali::LinearConstrainer *result = 0 ;
44178
44179   arg1 = (Dali::LinearConstrainer *)jarg1;
44180   arg2 = (Dali::LinearConstrainer *)jarg2;
44181   if (!arg2) {
44182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44183     return 0;
44184   }
44185   {
44186     try {
44187       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
44188     } catch (std::out_of_range& e) {
44189       {
44190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44191       };
44192     } catch (std::exception& e) {
44193       {
44194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44195       };
44196     } catch (Dali::DaliException e) {
44197       {
44198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44199       };
44200     } catch (...) {
44201       {
44202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44203       };
44204     }
44205   }
44206
44207   jresult = (void *)result;
44208   return jresult;
44209 }
44210
44211
44212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44213   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44214   SwigValueWrapper< Dali::Property > arg2 ;
44215   SwigValueWrapper< Dali::Property > arg3 ;
44216   Dali::Vector2 *arg4 = 0 ;
44217   Dali::Vector2 *arg5 = 0 ;
44218   Dali::Property *argp2 ;
44219   Dali::Property *argp3 ;
44220
44221   arg1 = (Dali::LinearConstrainer *)jarg1;
44222   argp2 = (Dali::Property *)jarg2;
44223   if (!argp2) {
44224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44225     return ;
44226   }
44227   arg2 = *argp2;
44228   argp3 = (Dali::Property *)jarg3;
44229   if (!argp3) {
44230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44231     return ;
44232   }
44233   arg3 = *argp3;
44234   arg4 = (Dali::Vector2 *)jarg4;
44235   if (!arg4) {
44236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44237     return ;
44238   }
44239   arg5 = (Dali::Vector2 *)jarg5;
44240   if (!arg5) {
44241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44242     return ;
44243   }
44244   {
44245     try {
44246       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44247     } catch (std::out_of_range& e) {
44248       {
44249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44250       };
44251     } catch (std::exception& e) {
44252       {
44253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44254       };
44255     } catch (Dali::DaliException e) {
44256       {
44257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44258       };
44259     } catch (...) {
44260       {
44261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44262       };
44263     }
44264   }
44265
44266 }
44267
44268
44269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44270   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44271   SwigValueWrapper< Dali::Property > arg2 ;
44272   SwigValueWrapper< Dali::Property > arg3 ;
44273   Dali::Vector2 *arg4 = 0 ;
44274   Dali::Property *argp2 ;
44275   Dali::Property *argp3 ;
44276
44277   arg1 = (Dali::LinearConstrainer *)jarg1;
44278   argp2 = (Dali::Property *)jarg2;
44279   if (!argp2) {
44280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44281     return ;
44282   }
44283   arg2 = *argp2;
44284   argp3 = (Dali::Property *)jarg3;
44285   if (!argp3) {
44286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44287     return ;
44288   }
44289   arg3 = *argp3;
44290   arg4 = (Dali::Vector2 *)jarg4;
44291   if (!arg4) {
44292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44293     return ;
44294   }
44295   {
44296     try {
44297       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44298     } catch (std::out_of_range& e) {
44299       {
44300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44301       };
44302     } catch (std::exception& e) {
44303       {
44304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44305       };
44306     } catch (Dali::DaliException e) {
44307       {
44308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44309       };
44310     } catch (...) {
44311       {
44312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44313       };
44314     }
44315   }
44316
44317 }
44318
44319
44320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
44321   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44322   Dali::Handle *arg2 = 0 ;
44323
44324   arg1 = (Dali::LinearConstrainer *)jarg1;
44325   arg2 = (Dali::Handle *)jarg2;
44326   if (!arg2) {
44327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44328     return ;
44329   }
44330   {
44331     try {
44332       (arg1)->Remove(*arg2);
44333     } catch (std::out_of_range& e) {
44334       {
44335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44336       };
44337     } catch (std::exception& e) {
44338       {
44339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44340       };
44341     } catch (Dali::DaliException e) {
44342       {
44343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44344       };
44345     } catch (...) {
44346       {
44347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44348       };
44349     }
44350   }
44351
44352 }
44353
44354
44355 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
44356   int jresult ;
44357   int result;
44358
44359   result = (int)Dali::PathConstrainer::Property::FORWARD;
44360   jresult = (int)result;
44361   return jresult;
44362 }
44363
44364
44365 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
44366   int jresult ;
44367   int result;
44368
44369   result = (int)Dali::PathConstrainer::Property::POINTS;
44370   jresult = (int)result;
44371   return jresult;
44372 }
44373
44374
44375 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
44376   int jresult ;
44377   int result;
44378
44379   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
44380   jresult = (int)result;
44381   return jresult;
44382 }
44383
44384
44385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
44386   void * jresult ;
44387   Dali::PathConstrainer::Property *result = 0 ;
44388
44389   {
44390     try {
44391       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
44392     } catch (std::out_of_range& e) {
44393       {
44394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44395       };
44396     } catch (std::exception& e) {
44397       {
44398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44399       };
44400     } catch (Dali::DaliException e) {
44401       {
44402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44403       };
44404     } catch (...) {
44405       {
44406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44407       };
44408     }
44409   }
44410
44411   jresult = (void *)result;
44412   return jresult;
44413 }
44414
44415
44416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
44417   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
44418
44419   arg1 = (Dali::PathConstrainer::Property *)jarg1;
44420   {
44421     try {
44422       delete arg1;
44423     } catch (std::out_of_range& e) {
44424       {
44425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44426       };
44427     } catch (std::exception& e) {
44428       {
44429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44430       };
44431     } catch (Dali::DaliException e) {
44432       {
44433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44434       };
44435     } catch (...) {
44436       {
44437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44438       };
44439     }
44440   }
44441
44442 }
44443
44444
44445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
44446   void * jresult ;
44447   Dali::PathConstrainer result;
44448
44449   {
44450     try {
44451       result = Dali::PathConstrainer::New();
44452     } catch (std::out_of_range& e) {
44453       {
44454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44455       };
44456     } catch (std::exception& e) {
44457       {
44458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44459       };
44460     } catch (Dali::DaliException e) {
44461       {
44462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44463       };
44464     } catch (...) {
44465       {
44466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44467       };
44468     }
44469   }
44470
44471   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44472   return jresult;
44473 }
44474
44475
44476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
44477   void * jresult ;
44478   Dali::BaseHandle arg1 ;
44479   Dali::BaseHandle *argp1 ;
44480   Dali::PathConstrainer result;
44481
44482   argp1 = (Dali::BaseHandle *)jarg1;
44483   if (!argp1) {
44484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44485     return 0;
44486   }
44487   arg1 = *argp1;
44488   {
44489     try {
44490       result = Dali::PathConstrainer::DownCast(arg1);
44491     } catch (std::out_of_range& e) {
44492       {
44493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44494       };
44495     } catch (std::exception& e) {
44496       {
44497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44498       };
44499     } catch (Dali::DaliException e) {
44500       {
44501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44502       };
44503     } catch (...) {
44504       {
44505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44506       };
44507     }
44508   }
44509
44510   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44511   return jresult;
44512 }
44513
44514
44515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
44516   void * jresult ;
44517   Dali::PathConstrainer *result = 0 ;
44518
44519   {
44520     try {
44521       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
44522     } catch (std::out_of_range& e) {
44523       {
44524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44525       };
44526     } catch (std::exception& e) {
44527       {
44528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44529       };
44530     } catch (Dali::DaliException e) {
44531       {
44532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44533       };
44534     } catch (...) {
44535       {
44536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44537       };
44538     }
44539   }
44540
44541   jresult = (void *)result;
44542   return jresult;
44543 }
44544
44545
44546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
44547   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44548
44549   arg1 = (Dali::PathConstrainer *)jarg1;
44550   {
44551     try {
44552       delete arg1;
44553     } catch (std::out_of_range& e) {
44554       {
44555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44556       };
44557     } catch (std::exception& e) {
44558       {
44559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44560       };
44561     } catch (Dali::DaliException e) {
44562       {
44563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44564       };
44565     } catch (...) {
44566       {
44567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44568       };
44569     }
44570   }
44571
44572 }
44573
44574
44575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
44576   void * jresult ;
44577   Dali::PathConstrainer *arg1 = 0 ;
44578   Dali::PathConstrainer *result = 0 ;
44579
44580   arg1 = (Dali::PathConstrainer *)jarg1;
44581   if (!arg1) {
44582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44583     return 0;
44584   }
44585   {
44586     try {
44587       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
44588     } catch (std::out_of_range& e) {
44589       {
44590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44591       };
44592     } catch (std::exception& e) {
44593       {
44594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44595       };
44596     } catch (Dali::DaliException e) {
44597       {
44598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44599       };
44600     } catch (...) {
44601       {
44602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44603       };
44604     }
44605   }
44606
44607   jresult = (void *)result;
44608   return jresult;
44609 }
44610
44611
44612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44613   void * jresult ;
44614   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44615   Dali::PathConstrainer *arg2 = 0 ;
44616   Dali::PathConstrainer *result = 0 ;
44617
44618   arg1 = (Dali::PathConstrainer *)jarg1;
44619   arg2 = (Dali::PathConstrainer *)jarg2;
44620   if (!arg2) {
44621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44622     return 0;
44623   }
44624   {
44625     try {
44626       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44627     } catch (std::out_of_range& e) {
44628       {
44629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44630       };
44631     } catch (std::exception& e) {
44632       {
44633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44634       };
44635     } catch (Dali::DaliException e) {
44636       {
44637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44638       };
44639     } catch (...) {
44640       {
44641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44642       };
44643     }
44644   }
44645
44646   jresult = (void *)result;
44647   return jresult;
44648 }
44649
44650
44651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44652   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44653   SwigValueWrapper< Dali::Property > arg2 ;
44654   SwigValueWrapper< Dali::Property > arg3 ;
44655   Dali::Vector2 *arg4 = 0 ;
44656   Dali::Vector2 *arg5 = 0 ;
44657   Dali::Property *argp2 ;
44658   Dali::Property *argp3 ;
44659
44660   arg1 = (Dali::PathConstrainer *)jarg1;
44661   argp2 = (Dali::Property *)jarg2;
44662   if (!argp2) {
44663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44664     return ;
44665   }
44666   arg2 = *argp2;
44667   argp3 = (Dali::Property *)jarg3;
44668   if (!argp3) {
44669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44670     return ;
44671   }
44672   arg3 = *argp3;
44673   arg4 = (Dali::Vector2 *)jarg4;
44674   if (!arg4) {
44675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44676     return ;
44677   }
44678   arg5 = (Dali::Vector2 *)jarg5;
44679   if (!arg5) {
44680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44681     return ;
44682   }
44683   {
44684     try {
44685       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44686     } catch (std::out_of_range& e) {
44687       {
44688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44689       };
44690     } catch (std::exception& e) {
44691       {
44692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44693       };
44694     } catch (Dali::DaliException e) {
44695       {
44696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44697       };
44698     } catch (...) {
44699       {
44700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44701       };
44702     }
44703   }
44704
44705 }
44706
44707
44708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44709   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44710   SwigValueWrapper< Dali::Property > arg2 ;
44711   SwigValueWrapper< Dali::Property > arg3 ;
44712   Dali::Vector2 *arg4 = 0 ;
44713   Dali::Property *argp2 ;
44714   Dali::Property *argp3 ;
44715
44716   arg1 = (Dali::PathConstrainer *)jarg1;
44717   argp2 = (Dali::Property *)jarg2;
44718   if (!argp2) {
44719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44720     return ;
44721   }
44722   arg2 = *argp2;
44723   argp3 = (Dali::Property *)jarg3;
44724   if (!argp3) {
44725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44726     return ;
44727   }
44728   arg3 = *argp3;
44729   arg4 = (Dali::Vector2 *)jarg4;
44730   if (!arg4) {
44731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44732     return ;
44733   }
44734   {
44735     try {
44736       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44737     } catch (std::out_of_range& e) {
44738       {
44739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44740       };
44741     } catch (std::exception& e) {
44742       {
44743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44744       };
44745     } catch (Dali::DaliException e) {
44746       {
44747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44748       };
44749     } catch (...) {
44750       {
44751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44752       };
44753     }
44754   }
44755
44756 }
44757
44758
44759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
44760   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44761   Dali::Handle *arg2 = 0 ;
44762
44763   arg1 = (Dali::PathConstrainer *)jarg1;
44764   arg2 = (Dali::Handle *)jarg2;
44765   if (!arg2) {
44766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44767     return ;
44768   }
44769   {
44770     try {
44771       (arg1)->Remove(*arg2);
44772     } catch (std::out_of_range& e) {
44773       {
44774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44775       };
44776     } catch (std::exception& e) {
44777       {
44778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44779       };
44780     } catch (Dali::DaliException e) {
44781       {
44782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44783       };
44784     } catch (...) {
44785       {
44786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44787       };
44788     }
44789   }
44790
44791 }
44792
44793
44794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
44795   int jresult ;
44796   Dali::FittingMode::Type result;
44797
44798   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
44799   jresult = (int)result;
44800   return jresult;
44801 }
44802
44803
44804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
44805   int jresult ;
44806   Dali::SamplingMode::Type result;
44807
44808   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
44809   jresult = (int)result;
44810   return jresult;
44811 }
44812
44813
44814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
44815   void * jresult ;
44816   Dali::BufferImage *result = 0 ;
44817
44818   {
44819     try {
44820       result = (Dali::BufferImage *)new Dali::BufferImage();
44821     } catch (std::out_of_range& e) {
44822       {
44823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44824       };
44825     } catch (std::exception& e) {
44826       {
44827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44828       };
44829     } catch (Dali::DaliException e) {
44830       {
44831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44832       };
44833     } catch (...) {
44834       {
44835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44836       };
44837     }
44838   }
44839
44840   jresult = (void *)result;
44841   return jresult;
44842 }
44843
44844
44845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
44846   void * jresult ;
44847   unsigned int arg1 ;
44848   unsigned int arg2 ;
44849   Dali::Pixel::Format arg3 ;
44850   Dali::BufferImage result;
44851
44852   arg1 = (unsigned int)jarg1;
44853   arg2 = (unsigned int)jarg2;
44854   arg3 = (Dali::Pixel::Format)jarg3;
44855   {
44856     try {
44857       result = Dali::BufferImage::New(arg1,arg2,arg3);
44858     } catch (std::out_of_range& e) {
44859       {
44860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44861       };
44862     } catch (std::exception& e) {
44863       {
44864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44865       };
44866     } catch (Dali::DaliException e) {
44867       {
44868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44869       };
44870     } catch (...) {
44871       {
44872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44873       };
44874     }
44875   }
44876
44877   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
44878   return jresult;
44879 }
44880
44881
44882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
44883   void * jresult ;
44884   unsigned int arg1 ;
44885   unsigned int arg2 ;
44886   Dali::BufferImage result;
44887
44888   arg1 = (unsigned int)jarg1;
44889   arg2 = (unsigned int)jarg2;
44890   {
44891     try {
44892       result = Dali::BufferImage::New(arg1,arg2);
44893     } catch (std::out_of_range& e) {
44894       {
44895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44896       };
44897     } catch (std::exception& e) {
44898       {
44899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44900       };
44901     } catch (Dali::DaliException e) {
44902       {
44903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44904       };
44905     } catch (...) {
44906       {
44907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44908       };
44909     }
44910   }
44911
44912   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
44913   return jresult;
44914 }
44915
44916
44917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
44918   void * jresult ;
44919   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
44920   unsigned int arg2 ;
44921   unsigned int arg3 ;
44922   Dali::Pixel::Format arg4 ;
44923   unsigned int arg5 ;
44924   Dali::BufferImage result;
44925
44926   arg1 = jarg1;
44927   arg2 = (unsigned int)jarg2;
44928   arg3 = (unsigned int)jarg3;
44929   arg4 = (Dali::Pixel::Format)jarg4;
44930   arg5 = (unsigned int)jarg5;
44931   {
44932     try {
44933       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
44934     } catch (std::out_of_range& e) {
44935       {
44936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44937       };
44938     } catch (std::exception& e) {
44939       {
44940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44941       };
44942     } catch (Dali::DaliException e) {
44943       {
44944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44945       };
44946     } catch (...) {
44947       {
44948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44949       };
44950     }
44951   }
44952
44953   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
44954
44955
44956   return jresult;
44957 }
44958
44959
44960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
44961   void * jresult ;
44962   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
44963   unsigned int arg2 ;
44964   unsigned int arg3 ;
44965   Dali::Pixel::Format arg4 ;
44966   Dali::BufferImage result;
44967
44968   arg1 = jarg1;
44969   arg2 = (unsigned int)jarg2;
44970   arg3 = (unsigned int)jarg3;
44971   arg4 = (Dali::Pixel::Format)jarg4;
44972   {
44973     try {
44974       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
44975     } catch (std::out_of_range& e) {
44976       {
44977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44978       };
44979     } catch (std::exception& e) {
44980       {
44981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44982       };
44983     } catch (Dali::DaliException e) {
44984       {
44985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44986       };
44987     } catch (...) {
44988       {
44989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44990       };
44991     }
44992   }
44993
44994   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
44995
44996
44997   return jresult;
44998 }
44999
45000
45001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
45002   void * jresult ;
45003   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45004   unsigned int arg2 ;
45005   unsigned int arg3 ;
45006   Dali::BufferImage result;
45007
45008   arg1 = jarg1;
45009   arg2 = (unsigned int)jarg2;
45010   arg3 = (unsigned int)jarg3;
45011   {
45012     try {
45013       result = Dali::BufferImage::New(arg1,arg2,arg3);
45014     } catch (std::out_of_range& e) {
45015       {
45016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45017       };
45018     } catch (std::exception& e) {
45019       {
45020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45021       };
45022     } catch (Dali::DaliException e) {
45023       {
45024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45025       };
45026     } catch (...) {
45027       {
45028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45029       };
45030     }
45031   }
45032
45033   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45034
45035
45036   return jresult;
45037 }
45038
45039
45040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
45041   void * jresult ;
45042   Dali::BaseHandle arg1 ;
45043   Dali::BaseHandle *argp1 ;
45044   Dali::BufferImage result;
45045
45046   argp1 = (Dali::BaseHandle *)jarg1;
45047   if (!argp1) {
45048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45049     return 0;
45050   }
45051   arg1 = *argp1;
45052   {
45053     try {
45054       result = Dali::BufferImage::DownCast(arg1);
45055     } catch (std::out_of_range& e) {
45056       {
45057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45058       };
45059     } catch (std::exception& e) {
45060       {
45061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45062       };
45063     } catch (Dali::DaliException e) {
45064       {
45065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45066       };
45067     } catch (...) {
45068       {
45069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45070       };
45071     }
45072   }
45073
45074   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45075   return jresult;
45076 }
45077
45078
45079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
45080   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45081
45082   arg1 = (Dali::BufferImage *)jarg1;
45083   {
45084     try {
45085       delete arg1;
45086     } catch (std::out_of_range& e) {
45087       {
45088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45089       };
45090     } catch (std::exception& e) {
45091       {
45092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45093       };
45094     } catch (Dali::DaliException e) {
45095       {
45096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45097       };
45098     } catch (...) {
45099       {
45100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45101       };
45102     }
45103   }
45104
45105 }
45106
45107
45108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
45109   void * jresult ;
45110   Dali::BufferImage *arg1 = 0 ;
45111   Dali::BufferImage *result = 0 ;
45112
45113   arg1 = (Dali::BufferImage *)jarg1;
45114   if (!arg1) {
45115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45116     return 0;
45117   }
45118   {
45119     try {
45120       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
45121     } catch (std::out_of_range& e) {
45122       {
45123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45124       };
45125     } catch (std::exception& e) {
45126       {
45127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45128       };
45129     } catch (Dali::DaliException e) {
45130       {
45131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45132       };
45133     } catch (...) {
45134       {
45135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45136       };
45137     }
45138   }
45139
45140   jresult = (void *)result;
45141   return jresult;
45142 }
45143
45144
45145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
45146   void * jresult ;
45147   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45148   Dali::BufferImage *arg2 = 0 ;
45149   Dali::BufferImage *result = 0 ;
45150
45151   arg1 = (Dali::BufferImage *)jarg1;
45152   arg2 = (Dali::BufferImage *)jarg2;
45153   if (!arg2) {
45154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45155     return 0;
45156   }
45157   {
45158     try {
45159       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
45160     } catch (std::out_of_range& e) {
45161       {
45162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45163       };
45164     } catch (std::exception& e) {
45165       {
45166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45167       };
45168     } catch (Dali::DaliException e) {
45169       {
45170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45171       };
45172     } catch (...) {
45173       {
45174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45175       };
45176     }
45177   }
45178
45179   jresult = (void *)result;
45180   return jresult;
45181 }
45182
45183
45184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
45185   void * jresult ;
45186   Dali::BufferImage result;
45187
45188   {
45189     try {
45190       result = Dali::BufferImage::WHITE();
45191     } catch (std::out_of_range& e) {
45192       {
45193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45194       };
45195     } catch (std::exception& e) {
45196       {
45197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45198       };
45199     } catch (Dali::DaliException e) {
45200       {
45201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45202       };
45203     } catch (...) {
45204       {
45205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45206       };
45207     }
45208   }
45209
45210   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45211   return jresult;
45212 }
45213
45214
45215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
45216   void * jresult ;
45217   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45218   Dali::PixelBuffer *result = 0 ;
45219
45220   arg1 = (Dali::BufferImage *)jarg1;
45221   {
45222     try {
45223       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
45224     } catch (std::out_of_range& e) {
45225       {
45226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45227       };
45228     } catch (std::exception& e) {
45229       {
45230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45231       };
45232     } catch (Dali::DaliException e) {
45233       {
45234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45235       };
45236     } catch (...) {
45237       {
45238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45239       };
45240     }
45241   }
45242
45243   jresult = (void *)result;
45244   return jresult;
45245 }
45246
45247
45248 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
45249   unsigned int jresult ;
45250   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45251   unsigned int result;
45252
45253   arg1 = (Dali::BufferImage *)jarg1;
45254   {
45255     try {
45256       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
45257     } catch (std::out_of_range& e) {
45258       {
45259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45260       };
45261     } catch (std::exception& e) {
45262       {
45263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45264       };
45265     } catch (Dali::DaliException e) {
45266       {
45267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45268       };
45269     } catch (...) {
45270       {
45271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45272       };
45273     }
45274   }
45275
45276   jresult = result;
45277   return jresult;
45278 }
45279
45280
45281 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
45282   unsigned int jresult ;
45283   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45284   unsigned int result;
45285
45286   arg1 = (Dali::BufferImage *)jarg1;
45287   {
45288     try {
45289       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
45290     } catch (std::out_of_range& e) {
45291       {
45292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45293       };
45294     } catch (std::exception& e) {
45295       {
45296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45297       };
45298     } catch (Dali::DaliException e) {
45299       {
45300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45301       };
45302     } catch (...) {
45303       {
45304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45305       };
45306     }
45307   }
45308
45309   jresult = result;
45310   return jresult;
45311 }
45312
45313
45314 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
45315   int jresult ;
45316   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45317   Dali::Pixel::Format result;
45318
45319   arg1 = (Dali::BufferImage *)jarg1;
45320   {
45321     try {
45322       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
45323     } catch (std::out_of_range& e) {
45324       {
45325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45326       };
45327     } catch (std::exception& e) {
45328       {
45329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45330       };
45331     } catch (Dali::DaliException e) {
45332       {
45333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45334       };
45335     } catch (...) {
45336       {
45337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45338       };
45339     }
45340   }
45341
45342   jresult = (int)result;
45343   return jresult;
45344 }
45345
45346
45347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
45348   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45349
45350   arg1 = (Dali::BufferImage *)jarg1;
45351   {
45352     try {
45353       (arg1)->Update();
45354     } catch (std::out_of_range& e) {
45355       {
45356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45357       };
45358     } catch (std::exception& e) {
45359       {
45360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45361       };
45362     } catch (Dali::DaliException e) {
45363       {
45364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45365       };
45366     } catch (...) {
45367       {
45368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45369       };
45370     }
45371   }
45372
45373 }
45374
45375
45376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
45377   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45378   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
45379   Dali::RectArea *argp2 ;
45380
45381   arg1 = (Dali::BufferImage *)jarg1;
45382   argp2 = (Dali::RectArea *)jarg2;
45383   if (!argp2) {
45384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
45385     return ;
45386   }
45387   arg2 = *argp2;
45388   {
45389     try {
45390       (arg1)->Update(arg2);
45391     } catch (std::out_of_range& e) {
45392       {
45393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45394       };
45395     } catch (std::exception& e) {
45396       {
45397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45398       };
45399     } catch (Dali::DaliException e) {
45400       {
45401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45402       };
45403     } catch (...) {
45404       {
45405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45406       };
45407     }
45408   }
45409
45410 }
45411
45412
45413 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
45414   unsigned int jresult ;
45415   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45416   bool result;
45417
45418   arg1 = (Dali::BufferImage *)jarg1;
45419   {
45420     try {
45421       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
45422     } catch (std::out_of_range& e) {
45423       {
45424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45425       };
45426     } catch (std::exception& e) {
45427       {
45428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45429       };
45430     } catch (Dali::DaliException e) {
45431       {
45432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45433       };
45434     } catch (...) {
45435       {
45436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45437       };
45438     }
45439   }
45440
45441   jresult = result;
45442   return jresult;
45443 }
45444
45445
45446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
45447   void * jresult ;
45448   Dali::EncodedBufferImage *result = 0 ;
45449
45450   {
45451     try {
45452       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
45453     } catch (std::out_of_range& e) {
45454       {
45455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45456       };
45457     } catch (std::exception& e) {
45458       {
45459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45460       };
45461     } catch (Dali::DaliException e) {
45462       {
45463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45464       };
45465     } catch (...) {
45466       {
45467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45468       };
45469     }
45470   }
45471
45472   jresult = (void *)result;
45473   return jresult;
45474 }
45475
45476
45477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
45478   void * jresult ;
45479   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45480   std::size_t arg2 ;
45481   Dali::EncodedBufferImage result;
45482
45483   arg1 = (uint8_t *)jarg1;
45484   arg2 = (std::size_t)jarg2;
45485   {
45486     try {
45487       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
45488     } catch (std::out_of_range& e) {
45489       {
45490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45491       };
45492     } catch (std::exception& e) {
45493       {
45494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45495       };
45496     } catch (Dali::DaliException e) {
45497       {
45498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45499       };
45500     } catch (...) {
45501       {
45502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45503       };
45504     }
45505   }
45506
45507   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45508   return jresult;
45509 }
45510
45511
45512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
45513   void * jresult ;
45514   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45515   std::size_t arg2 ;
45516   Dali::ImageDimensions arg3 ;
45517   Dali::FittingMode::Type arg4 ;
45518   Dali::SamplingMode::Type arg5 ;
45519   bool arg6 ;
45520   Dali::ImageDimensions *argp3 ;
45521   Dali::EncodedBufferImage result;
45522
45523   arg1 = (uint8_t *)jarg1;
45524   arg2 = (std::size_t)jarg2;
45525   argp3 = (Dali::ImageDimensions *)jarg3;
45526   if (!argp3) {
45527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45528     return 0;
45529   }
45530   arg3 = *argp3;
45531   arg4 = (Dali::FittingMode::Type)jarg4;
45532   arg5 = (Dali::SamplingMode::Type)jarg5;
45533   arg6 = jarg6 ? true : false;
45534   {
45535     try {
45536       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
45537     } catch (std::out_of_range& e) {
45538       {
45539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45540       };
45541     } catch (std::exception& e) {
45542       {
45543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45544       };
45545     } catch (Dali::DaliException e) {
45546       {
45547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45548       };
45549     } catch (...) {
45550       {
45551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45552       };
45553     }
45554   }
45555
45556   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45557   return jresult;
45558 }
45559
45560
45561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
45562   void * jresult ;
45563   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45564   std::size_t arg2 ;
45565   Dali::ImageDimensions arg3 ;
45566   Dali::FittingMode::Type arg4 ;
45567   Dali::SamplingMode::Type arg5 ;
45568   Dali::ImageDimensions *argp3 ;
45569   Dali::EncodedBufferImage result;
45570
45571   arg1 = (uint8_t *)jarg1;
45572   arg2 = (std::size_t)jarg2;
45573   argp3 = (Dali::ImageDimensions *)jarg3;
45574   if (!argp3) {
45575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45576     return 0;
45577   }
45578   arg3 = *argp3;
45579   arg4 = (Dali::FittingMode::Type)jarg4;
45580   arg5 = (Dali::SamplingMode::Type)jarg5;
45581   {
45582     try {
45583       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
45584     } catch (std::out_of_range& e) {
45585       {
45586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45587       };
45588     } catch (std::exception& e) {
45589       {
45590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45591       };
45592     } catch (Dali::DaliException e) {
45593       {
45594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45595       };
45596     } catch (...) {
45597       {
45598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45599       };
45600     }
45601   }
45602
45603   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45604   return jresult;
45605 }
45606
45607
45608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
45609   void * jresult ;
45610   Dali::BaseHandle arg1 ;
45611   Dali::BaseHandle *argp1 ;
45612   Dali::EncodedBufferImage result;
45613
45614   argp1 = (Dali::BaseHandle *)jarg1;
45615   if (!argp1) {
45616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45617     return 0;
45618   }
45619   arg1 = *argp1;
45620   {
45621     try {
45622       result = Dali::EncodedBufferImage::DownCast(arg1);
45623     } catch (std::out_of_range& e) {
45624       {
45625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45626       };
45627     } catch (std::exception& e) {
45628       {
45629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45630       };
45631     } catch (Dali::DaliException e) {
45632       {
45633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45634       };
45635     } catch (...) {
45636       {
45637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45638       };
45639     }
45640   }
45641
45642   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45643   return jresult;
45644 }
45645
45646
45647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
45648   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45649
45650   arg1 = (Dali::EncodedBufferImage *)jarg1;
45651   {
45652     try {
45653       delete arg1;
45654     } catch (std::out_of_range& e) {
45655       {
45656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45657       };
45658     } catch (std::exception& e) {
45659       {
45660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45661       };
45662     } catch (Dali::DaliException e) {
45663       {
45664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45665       };
45666     } catch (...) {
45667       {
45668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45669       };
45670     }
45671   }
45672
45673 }
45674
45675
45676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
45677   void * jresult ;
45678   Dali::EncodedBufferImage *arg1 = 0 ;
45679   Dali::EncodedBufferImage *result = 0 ;
45680
45681   arg1 = (Dali::EncodedBufferImage *)jarg1;
45682   if (!arg1) {
45683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45684     return 0;
45685   }
45686   {
45687     try {
45688       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
45689     } catch (std::out_of_range& e) {
45690       {
45691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45692       };
45693     } catch (std::exception& e) {
45694       {
45695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45696       };
45697     } catch (Dali::DaliException e) {
45698       {
45699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45700       };
45701     } catch (...) {
45702       {
45703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45704       };
45705     }
45706   }
45707
45708   jresult = (void *)result;
45709   return jresult;
45710 }
45711
45712
45713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
45714   void * jresult ;
45715   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45716   Dali::EncodedBufferImage *arg2 = 0 ;
45717   Dali::EncodedBufferImage *result = 0 ;
45718
45719   arg1 = (Dali::EncodedBufferImage *)jarg1;
45720   arg2 = (Dali::EncodedBufferImage *)jarg2;
45721   if (!arg2) {
45722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45723     return 0;
45724   }
45725   {
45726     try {
45727       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
45728     } catch (std::out_of_range& e) {
45729       {
45730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45731       };
45732     } catch (std::exception& e) {
45733       {
45734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45735       };
45736     } catch (Dali::DaliException e) {
45737       {
45738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45739       };
45740     } catch (...) {
45741       {
45742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45743       };
45744     }
45745   }
45746
45747   jresult = (void *)result;
45748   return jresult;
45749 }
45750
45751
45752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
45753   void * jresult ;
45754   Dali::NativeImage *result = 0 ;
45755
45756   {
45757     try {
45758       result = (Dali::NativeImage *)new Dali::NativeImage();
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 = (void *)result;
45779   return jresult;
45780 }
45781
45782
45783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
45784   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
45785
45786   arg1 = (Dali::NativeImage *)jarg1;
45787   {
45788     try {
45789       delete arg1;
45790     } catch (std::out_of_range& e) {
45791       {
45792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45793       };
45794     } catch (std::exception& e) {
45795       {
45796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45797       };
45798     } catch (Dali::DaliException e) {
45799       {
45800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45801       };
45802     } catch (...) {
45803       {
45804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45805       };
45806     }
45807   }
45808
45809 }
45810
45811
45812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
45813   void * jresult ;
45814   Dali::NativeImage *arg1 = 0 ;
45815   Dali::NativeImage *result = 0 ;
45816
45817   arg1 = (Dali::NativeImage *)jarg1;
45818   if (!arg1) {
45819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
45820     return 0;
45821   }
45822   {
45823     try {
45824       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
45825     } catch (std::out_of_range& e) {
45826       {
45827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45828       };
45829     } catch (std::exception& e) {
45830       {
45831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45832       };
45833     } catch (Dali::DaliException e) {
45834       {
45835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45836       };
45837     } catch (...) {
45838       {
45839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45840       };
45841     }
45842   }
45843
45844   jresult = (void *)result;
45845   return jresult;
45846 }
45847
45848
45849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
45850   void * jresult ;
45851   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
45852   Dali::NativeImage *arg2 = 0 ;
45853   Dali::NativeImage *result = 0 ;
45854
45855   arg1 = (Dali::NativeImage *)jarg1;
45856   arg2 = (Dali::NativeImage *)jarg2;
45857   if (!arg2) {
45858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
45859     return 0;
45860   }
45861   {
45862     try {
45863       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
45864     } catch (std::out_of_range& e) {
45865       {
45866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45867       };
45868     } catch (std::exception& e) {
45869       {
45870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45871       };
45872     } catch (Dali::DaliException e) {
45873       {
45874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45875       };
45876     } catch (...) {
45877       {
45878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45879       };
45880     }
45881   }
45882
45883   jresult = (void *)result;
45884   return jresult;
45885 }
45886
45887
45888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
45889   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
45890
45891   arg1 = (Dali::NativeImage *)jarg1;
45892   {
45893     try {
45894       (arg1)->CreateGlTexture();
45895     } catch (std::out_of_range& e) {
45896       {
45897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45898       };
45899     } catch (std::exception& e) {
45900       {
45901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45902       };
45903     } catch (Dali::DaliException e) {
45904       {
45905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45906       };
45907     } catch (...) {
45908       {
45909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45910       };
45911     }
45912   }
45913
45914 }
45915
45916
45917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
45918   void * jresult ;
45919   NativeImageInterface *arg1 = 0 ;
45920   Dali::NativeImage result;
45921
45922   arg1 = (NativeImageInterface *)jarg1;
45923   if (!arg1) {
45924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
45925     return 0;
45926   }
45927   {
45928     try {
45929       result = Dali::NativeImage::New(*arg1);
45930     } catch (std::out_of_range& e) {
45931       {
45932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45933       };
45934     } catch (std::exception& e) {
45935       {
45936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45937       };
45938     } catch (Dali::DaliException e) {
45939       {
45940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45941       };
45942     } catch (...) {
45943       {
45944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45945       };
45946     }
45947   }
45948
45949   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
45950   return jresult;
45951 }
45952
45953
45954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
45955   void * jresult ;
45956   Dali::BaseHandle arg1 ;
45957   Dali::BaseHandle *argp1 ;
45958   Dali::NativeImage result;
45959
45960   argp1 = (Dali::BaseHandle *)jarg1;
45961   if (!argp1) {
45962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45963     return 0;
45964   }
45965   arg1 = *argp1;
45966   {
45967     try {
45968       result = Dali::NativeImage::DownCast(arg1);
45969     } catch (std::out_of_range& e) {
45970       {
45971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45972       };
45973     } catch (std::exception& e) {
45974       {
45975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45976       };
45977     } catch (Dali::DaliException e) {
45978       {
45979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45980       };
45981     } catch (...) {
45982       {
45983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45984       };
45985     }
45986   }
45987
45988   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
45989   return jresult;
45990 }
45991
45992
45993 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
45994   char * jresult ;
45995   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
45996   char *result = 0 ;
45997
45998   arg1 = (Dali::NativeImage *)jarg1;
45999   {
46000     try {
46001       result = (char *)(arg1)->GetCustomFragmentPreFix();
46002     } catch (std::out_of_range& e) {
46003       {
46004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46005       };
46006     } catch (std::exception& e) {
46007       {
46008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46009       };
46010     } catch (Dali::DaliException e) {
46011       {
46012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46013       };
46014     } catch (...) {
46015       {
46016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46017       };
46018     }
46019   }
46020
46021   jresult = SWIG_csharp_string_callback((const char *)result);
46022   return jresult;
46023 }
46024
46025
46026 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
46027   char * jresult ;
46028   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46029   char *result = 0 ;
46030
46031   arg1 = (Dali::NativeImage *)jarg1;
46032   {
46033     try {
46034       result = (char *)(arg1)->GetCustomSamplerTypename();
46035     } catch (std::out_of_range& e) {
46036       {
46037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46038       };
46039     } catch (std::exception& e) {
46040       {
46041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46042       };
46043     } catch (Dali::DaliException e) {
46044       {
46045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46046       };
46047     } catch (...) {
46048       {
46049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46050       };
46051     }
46052   }
46053
46054   jresult = SWIG_csharp_string_callback((const char *)result);
46055   return jresult;
46056 }
46057
46058
46059 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
46060   unsigned int jresult ;
46061   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46062   bool result;
46063
46064   arg1 = (Dali::NativeImageInterface *)jarg1;
46065   {
46066     try {
46067       result = (bool)(arg1)->GlExtensionCreate();
46068     } catch (std::out_of_range& e) {
46069       {
46070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46071       };
46072     } catch (std::exception& e) {
46073       {
46074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46075       };
46076     } catch (Dali::DaliException e) {
46077       {
46078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46079       };
46080     } catch (...) {
46081       {
46082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46083       };
46084     }
46085   }
46086
46087   jresult = result;
46088   return jresult;
46089 }
46090
46091
46092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
46093   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46094
46095   arg1 = (Dali::NativeImageInterface *)jarg1;
46096   {
46097     try {
46098       (arg1)->GlExtensionDestroy();
46099     } catch (std::out_of_range& e) {
46100       {
46101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46102       };
46103     } catch (std::exception& e) {
46104       {
46105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46106       };
46107     } catch (Dali::DaliException e) {
46108       {
46109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46110       };
46111     } catch (...) {
46112       {
46113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46114       };
46115     }
46116   }
46117
46118 }
46119
46120
46121 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
46122   unsigned int jresult ;
46123   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46124   unsigned int result;
46125
46126   arg1 = (Dali::NativeImageInterface *)jarg1;
46127   {
46128     try {
46129       result = (unsigned int)(arg1)->TargetTexture();
46130     } catch (std::out_of_range& e) {
46131       {
46132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46133       };
46134     } catch (std::exception& e) {
46135       {
46136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46137       };
46138     } catch (Dali::DaliException e) {
46139       {
46140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46141       };
46142     } catch (...) {
46143       {
46144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46145       };
46146     }
46147   }
46148
46149   jresult = result;
46150   return jresult;
46151 }
46152
46153
46154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
46155   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46156
46157   arg1 = (Dali::NativeImageInterface *)jarg1;
46158   {
46159     try {
46160       (arg1)->PrepareTexture();
46161     } catch (std::out_of_range& e) {
46162       {
46163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46164       };
46165     } catch (std::exception& e) {
46166       {
46167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46168       };
46169     } catch (Dali::DaliException e) {
46170       {
46171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46172       };
46173     } catch (...) {
46174       {
46175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46176       };
46177     }
46178   }
46179
46180 }
46181
46182
46183 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
46184   unsigned int jresult ;
46185   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46186   unsigned int result;
46187
46188   arg1 = (Dali::NativeImageInterface *)jarg1;
46189   {
46190     try {
46191       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
46192     } catch (std::out_of_range& e) {
46193       {
46194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46195       };
46196     } catch (std::exception& e) {
46197       {
46198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46199       };
46200     } catch (Dali::DaliException e) {
46201       {
46202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46203       };
46204     } catch (...) {
46205       {
46206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46207       };
46208     }
46209   }
46210
46211   jresult = result;
46212   return jresult;
46213 }
46214
46215
46216 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
46217   unsigned int jresult ;
46218   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46219   unsigned int result;
46220
46221   arg1 = (Dali::NativeImageInterface *)jarg1;
46222   {
46223     try {
46224       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
46225     } catch (std::out_of_range& e) {
46226       {
46227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46228       };
46229     } catch (std::exception& e) {
46230       {
46231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46232       };
46233     } catch (Dali::DaliException e) {
46234       {
46235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46236       };
46237     } catch (...) {
46238       {
46239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46240       };
46241     }
46242   }
46243
46244   jresult = result;
46245   return jresult;
46246 }
46247
46248
46249 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
46250   unsigned int jresult ;
46251   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46252   bool result;
46253
46254   arg1 = (Dali::NativeImageInterface *)jarg1;
46255   {
46256     try {
46257       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
46258     } catch (std::out_of_range& e) {
46259       {
46260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46261       };
46262     } catch (std::exception& e) {
46263       {
46264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46265       };
46266     } catch (Dali::DaliException e) {
46267       {
46268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46269       };
46270     } catch (...) {
46271       {
46272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46273       };
46274     }
46275   }
46276
46277   jresult = result;
46278   return jresult;
46279 }
46280
46281
46282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
46283   void * jresult ;
46284   std::string *arg1 = 0 ;
46285   Dali::ImageDimensions result;
46286
46287   if (!jarg1) {
46288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46289     return 0;
46290   }
46291   std::string arg1_str(jarg1);
46292   arg1 = &arg1_str;
46293   {
46294     try {
46295       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
46296     } catch (std::out_of_range& e) {
46297       {
46298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46299       };
46300     } catch (std::exception& e) {
46301       {
46302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46303       };
46304     } catch (Dali::DaliException e) {
46305       {
46306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46307       };
46308     } catch (...) {
46309       {
46310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46311       };
46312     }
46313   }
46314
46315   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
46316
46317   //argout typemap for const std::string&
46318
46319   return jresult;
46320 }
46321
46322
46323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
46324   void * jresult ;
46325   Dali::ResourceImage *result = 0 ;
46326
46327   {
46328     try {
46329       result = (Dali::ResourceImage *)new Dali::ResourceImage();
46330     } catch (std::out_of_range& e) {
46331       {
46332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46333       };
46334     } catch (std::exception& e) {
46335       {
46336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46337       };
46338     } catch (Dali::DaliException e) {
46339       {
46340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46341       };
46342     } catch (...) {
46343       {
46344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46345       };
46346     }
46347   }
46348
46349   jresult = (void *)result;
46350   return jresult;
46351 }
46352
46353
46354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
46355   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46356
46357   arg1 = (Dali::ResourceImage *)jarg1;
46358   {
46359     try {
46360       delete arg1;
46361     } catch (std::out_of_range& e) {
46362       {
46363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46364       };
46365     } catch (std::exception& e) {
46366       {
46367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46368       };
46369     } catch (Dali::DaliException e) {
46370       {
46371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46372       };
46373     } catch (...) {
46374       {
46375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46376       };
46377     }
46378   }
46379
46380 }
46381
46382
46383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
46384   void * jresult ;
46385   Dali::ResourceImage *arg1 = 0 ;
46386   Dali::ResourceImage *result = 0 ;
46387
46388   arg1 = (Dali::ResourceImage *)jarg1;
46389   if (!arg1) {
46390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46391     return 0;
46392   }
46393   {
46394     try {
46395       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
46396     } catch (std::out_of_range& e) {
46397       {
46398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46399       };
46400     } catch (std::exception& e) {
46401       {
46402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46403       };
46404     } catch (Dali::DaliException e) {
46405       {
46406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46407       };
46408     } catch (...) {
46409       {
46410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46411       };
46412     }
46413   }
46414
46415   jresult = (void *)result;
46416   return jresult;
46417 }
46418
46419
46420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
46421   void * jresult ;
46422   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46423   Dali::ResourceImage *arg2 = 0 ;
46424   Dali::ResourceImage *result = 0 ;
46425
46426   arg1 = (Dali::ResourceImage *)jarg1;
46427   arg2 = (Dali::ResourceImage *)jarg2;
46428   if (!arg2) {
46429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46430     return 0;
46431   }
46432   {
46433     try {
46434       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
46435     } catch (std::out_of_range& e) {
46436       {
46437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46438       };
46439     } catch (std::exception& e) {
46440       {
46441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46442       };
46443     } catch (Dali::DaliException e) {
46444       {
46445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46446       };
46447     } catch (...) {
46448       {
46449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46450       };
46451     }
46452   }
46453
46454   jresult = (void *)result;
46455   return jresult;
46456 }
46457
46458
46459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
46460   void * jresult ;
46461   std::string *arg1 = 0 ;
46462   bool arg2 ;
46463   Dali::ResourceImage result;
46464
46465   if (!jarg1) {
46466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46467     return 0;
46468   }
46469   std::string arg1_str(jarg1);
46470   arg1 = &arg1_str;
46471   arg2 = jarg2 ? true : false;
46472   {
46473     try {
46474       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46475     } catch (std::out_of_range& e) {
46476       {
46477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46478       };
46479     } catch (std::exception& e) {
46480       {
46481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46482       };
46483     } catch (Dali::DaliException e) {
46484       {
46485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46486       };
46487     } catch (...) {
46488       {
46489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46490       };
46491     }
46492   }
46493
46494   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46495
46496   //argout typemap for const std::string&
46497
46498   return jresult;
46499 }
46500
46501
46502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
46503   void * jresult ;
46504   std::string *arg1 = 0 ;
46505   Dali::ResourceImage result;
46506
46507   if (!jarg1) {
46508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46509     return 0;
46510   }
46511   std::string arg1_str(jarg1);
46512   arg1 = &arg1_str;
46513   {
46514     try {
46515       result = Dali::ResourceImage::New((std::string const &)*arg1);
46516     } catch (std::out_of_range& e) {
46517       {
46518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46519       };
46520     } catch (std::exception& e) {
46521       {
46522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46523       };
46524     } catch (Dali::DaliException e) {
46525       {
46526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46527       };
46528     } catch (...) {
46529       {
46530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46531       };
46532     }
46533   }
46534
46535   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46536
46537   //argout typemap for const std::string&
46538
46539   return jresult;
46540 }
46541
46542
46543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
46544   void * jresult ;
46545   std::string *arg1 = 0 ;
46546   Dali::ImageDimensions arg2 ;
46547   Dali::FittingMode::Type arg3 ;
46548   Dali::SamplingMode::Type arg4 ;
46549   bool arg5 ;
46550   Dali::ImageDimensions *argp2 ;
46551   Dali::ResourceImage result;
46552
46553   if (!jarg1) {
46554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46555     return 0;
46556   }
46557   std::string arg1_str(jarg1);
46558   arg1 = &arg1_str;
46559   argp2 = (Dali::ImageDimensions *)jarg2;
46560   if (!argp2) {
46561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46562     return 0;
46563   }
46564   arg2 = *argp2;
46565   arg3 = (Dali::FittingMode::Type)jarg3;
46566   arg4 = (Dali::SamplingMode::Type)jarg4;
46567   arg5 = jarg5 ? true : false;
46568   {
46569     try {
46570       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
46571     } catch (std::out_of_range& e) {
46572       {
46573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46574       };
46575     } catch (std::exception& e) {
46576       {
46577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46578       };
46579     } catch (Dali::DaliException e) {
46580       {
46581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46582       };
46583     } catch (...) {
46584       {
46585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46586       };
46587     }
46588   }
46589
46590   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46591
46592   //argout typemap for const std::string&
46593
46594   return jresult;
46595 }
46596
46597
46598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
46599   void * jresult ;
46600   std::string *arg1 = 0 ;
46601   Dali::ImageDimensions arg2 ;
46602   Dali::FittingMode::Type arg3 ;
46603   Dali::SamplingMode::Type arg4 ;
46604   Dali::ImageDimensions *argp2 ;
46605   Dali::ResourceImage result;
46606
46607   if (!jarg1) {
46608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46609     return 0;
46610   }
46611   std::string arg1_str(jarg1);
46612   arg1 = &arg1_str;
46613   argp2 = (Dali::ImageDimensions *)jarg2;
46614   if (!argp2) {
46615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46616     return 0;
46617   }
46618   arg2 = *argp2;
46619   arg3 = (Dali::FittingMode::Type)jarg3;
46620   arg4 = (Dali::SamplingMode::Type)jarg4;
46621   {
46622     try {
46623       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
46624     } catch (std::out_of_range& e) {
46625       {
46626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46627       };
46628     } catch (std::exception& e) {
46629       {
46630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46631       };
46632     } catch (Dali::DaliException e) {
46633       {
46634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46635       };
46636     } catch (...) {
46637       {
46638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46639       };
46640     }
46641   }
46642
46643   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46644
46645   //argout typemap for const std::string&
46646
46647   return jresult;
46648 }
46649
46650
46651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
46652   void * jresult ;
46653   std::string *arg1 = 0 ;
46654   Dali::ImageDimensions arg2 ;
46655   Dali::FittingMode::Type arg3 ;
46656   Dali::ImageDimensions *argp2 ;
46657   Dali::ResourceImage result;
46658
46659   if (!jarg1) {
46660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46661     return 0;
46662   }
46663   std::string arg1_str(jarg1);
46664   arg1 = &arg1_str;
46665   argp2 = (Dali::ImageDimensions *)jarg2;
46666   if (!argp2) {
46667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46668     return 0;
46669   }
46670   arg2 = *argp2;
46671   arg3 = (Dali::FittingMode::Type)jarg3;
46672   {
46673     try {
46674       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
46675     } catch (std::out_of_range& e) {
46676       {
46677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46678       };
46679     } catch (std::exception& e) {
46680       {
46681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46682       };
46683     } catch (Dali::DaliException e) {
46684       {
46685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46686       };
46687     } catch (...) {
46688       {
46689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46690       };
46691     }
46692   }
46693
46694   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46695
46696   //argout typemap for const std::string&
46697
46698   return jresult;
46699 }
46700
46701
46702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
46703   void * jresult ;
46704   std::string *arg1 = 0 ;
46705   Dali::ImageDimensions arg2 ;
46706   Dali::ImageDimensions *argp2 ;
46707   Dali::ResourceImage result;
46708
46709   if (!jarg1) {
46710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46711     return 0;
46712   }
46713   std::string arg1_str(jarg1);
46714   arg1 = &arg1_str;
46715   argp2 = (Dali::ImageDimensions *)jarg2;
46716   if (!argp2) {
46717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46718     return 0;
46719   }
46720   arg2 = *argp2;
46721   {
46722     try {
46723       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46724     } catch (std::out_of_range& e) {
46725       {
46726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46727       };
46728     } catch (std::exception& e) {
46729       {
46730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46731       };
46732     } catch (Dali::DaliException e) {
46733       {
46734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46735       };
46736     } catch (...) {
46737       {
46738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46739       };
46740     }
46741   }
46742
46743   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46744
46745   //argout typemap for const std::string&
46746
46747   return jresult;
46748 }
46749
46750
46751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
46752   void * jresult ;
46753   Dali::BaseHandle arg1 ;
46754   Dali::BaseHandle *argp1 ;
46755   Dali::ResourceImage result;
46756
46757   argp1 = (Dali::BaseHandle *)jarg1;
46758   if (!argp1) {
46759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46760     return 0;
46761   }
46762   arg1 = *argp1;
46763   {
46764     try {
46765       result = Dali::ResourceImage::DownCast(arg1);
46766     } catch (std::out_of_range& e) {
46767       {
46768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46769       };
46770     } catch (std::exception& e) {
46771       {
46772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46773       };
46774     } catch (Dali::DaliException e) {
46775       {
46776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46777       };
46778     } catch (...) {
46779       {
46780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46781       };
46782     }
46783   }
46784
46785   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46786   return jresult;
46787 }
46788
46789
46790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
46791   int jresult ;
46792   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46793   Dali::LoadingState result;
46794
46795   arg1 = (Dali::ResourceImage *)jarg1;
46796   {
46797     try {
46798       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
46799     } catch (std::out_of_range& e) {
46800       {
46801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46802       };
46803     } catch (std::exception& e) {
46804       {
46805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46806       };
46807     } catch (Dali::DaliException e) {
46808       {
46809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46810       };
46811     } catch (...) {
46812       {
46813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46814       };
46815     }
46816   }
46817
46818   jresult = (int)result;
46819   return jresult;
46820 }
46821
46822
46823 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
46824   char * jresult ;
46825   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46826   std::string result;
46827
46828   arg1 = (Dali::ResourceImage *)jarg1;
46829   {
46830     try {
46831       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
46832     } catch (std::out_of_range& e) {
46833       {
46834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46835       };
46836     } catch (std::exception& e) {
46837       {
46838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46839       };
46840     } catch (Dali::DaliException e) {
46841       {
46842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46843       };
46844     } catch (...) {
46845       {
46846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46847       };
46848     }
46849   }
46850
46851   jresult = SWIG_csharp_string_callback((&result)->c_str());
46852   return jresult;
46853 }
46854
46855
46856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
46857   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46858
46859   arg1 = (Dali::ResourceImage *)jarg1;
46860   {
46861     try {
46862       (arg1)->Reload();
46863     } catch (std::out_of_range& e) {
46864       {
46865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46866       };
46867     } catch (std::exception& e) {
46868       {
46869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46870       };
46871     } catch (Dali::DaliException e) {
46872       {
46873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46874       };
46875     } catch (...) {
46876       {
46877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46878       };
46879     }
46880   }
46881
46882 }
46883
46884
46885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
46886   void * jresult ;
46887   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46888   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
46889
46890   arg1 = (Dali::ResourceImage *)jarg1;
46891   {
46892     try {
46893       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
46894     } catch (std::out_of_range& e) {
46895       {
46896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46897       };
46898     } catch (std::exception& e) {
46899       {
46900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46901       };
46902     } catch (Dali::DaliException e) {
46903       {
46904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46905       };
46906     } catch (...) {
46907       {
46908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46909       };
46910     }
46911   }
46912
46913   jresult = (void *)result;
46914   return jresult;
46915 }
46916
46917
46918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
46919   void * jresult ;
46920   Dali::FrameBufferImage *result = 0 ;
46921
46922   {
46923     try {
46924       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
46925     } catch (std::out_of_range& e) {
46926       {
46927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46928       };
46929     } catch (std::exception& e) {
46930       {
46931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46932       };
46933     } catch (Dali::DaliException e) {
46934       {
46935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46936       };
46937     } catch (...) {
46938       {
46939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46940       };
46941     }
46942   }
46943
46944   jresult = (void *)result;
46945   return jresult;
46946 }
46947
46948
46949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
46950   void * jresult ;
46951   unsigned int arg1 ;
46952   unsigned int arg2 ;
46953   Dali::Pixel::Format arg3 ;
46954   Dali::RenderBuffer::Format arg4 ;
46955   Dali::FrameBufferImage result;
46956
46957   arg1 = (unsigned int)jarg1;
46958   arg2 = (unsigned int)jarg2;
46959   arg3 = (Dali::Pixel::Format)jarg3;
46960   arg4 = (Dali::RenderBuffer::Format)jarg4;
46961   {
46962     try {
46963       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
46964     } catch (std::out_of_range& e) {
46965       {
46966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46967       };
46968     } catch (std::exception& e) {
46969       {
46970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46971       };
46972     } catch (Dali::DaliException e) {
46973       {
46974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46975       };
46976     } catch (...) {
46977       {
46978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46979       };
46980     }
46981   }
46982
46983   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
46984   return jresult;
46985 }
46986
46987
46988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
46989   void * jresult ;
46990   unsigned int arg1 ;
46991   unsigned int arg2 ;
46992   Dali::Pixel::Format arg3 ;
46993   Dali::FrameBufferImage result;
46994
46995   arg1 = (unsigned int)jarg1;
46996   arg2 = (unsigned int)jarg2;
46997   arg3 = (Dali::Pixel::Format)jarg3;
46998   {
46999     try {
47000       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
47001     } catch (std::out_of_range& e) {
47002       {
47003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47004       };
47005     } catch (std::exception& e) {
47006       {
47007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47008       };
47009     } catch (Dali::DaliException e) {
47010       {
47011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47012       };
47013     } catch (...) {
47014       {
47015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47016       };
47017     }
47018   }
47019
47020   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47021   return jresult;
47022 }
47023
47024
47025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
47026   void * jresult ;
47027   unsigned int arg1 ;
47028   unsigned int arg2 ;
47029   Dali::FrameBufferImage result;
47030
47031   arg1 = (unsigned int)jarg1;
47032   arg2 = (unsigned int)jarg2;
47033   {
47034     try {
47035       result = Dali::FrameBufferImage::New(arg1,arg2);
47036     } catch (std::out_of_range& e) {
47037       {
47038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47039       };
47040     } catch (std::exception& e) {
47041       {
47042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47043       };
47044     } catch (Dali::DaliException e) {
47045       {
47046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47047       };
47048     } catch (...) {
47049       {
47050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47051       };
47052     }
47053   }
47054
47055   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47056   return jresult;
47057 }
47058
47059
47060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
47061   void * jresult ;
47062   unsigned int arg1 ;
47063   Dali::FrameBufferImage result;
47064
47065   arg1 = (unsigned int)jarg1;
47066   {
47067     try {
47068       result = Dali::FrameBufferImage::New(arg1);
47069     } catch (std::out_of_range& e) {
47070       {
47071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47072       };
47073     } catch (std::exception& e) {
47074       {
47075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47076       };
47077     } catch (Dali::DaliException e) {
47078       {
47079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47080       };
47081     } catch (...) {
47082       {
47083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47084       };
47085     }
47086   }
47087
47088   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47089   return jresult;
47090 }
47091
47092
47093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
47094   void * jresult ;
47095   Dali::FrameBufferImage result;
47096
47097   {
47098     try {
47099       result = Dali::FrameBufferImage::New();
47100     } catch (std::out_of_range& e) {
47101       {
47102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47103       };
47104     } catch (std::exception& e) {
47105       {
47106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47107       };
47108     } catch (Dali::DaliException e) {
47109       {
47110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47111       };
47112     } catch (...) {
47113       {
47114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47115       };
47116     }
47117   }
47118
47119   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47120   return jresult;
47121 }
47122
47123
47124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
47125   void * jresult ;
47126   Dali::NativeImageInterface *arg1 = 0 ;
47127   Dali::FrameBufferImage result;
47128
47129   arg1 = (Dali::NativeImageInterface *)jarg1;
47130   if (!arg1) {
47131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
47132     return 0;
47133   }
47134   {
47135     try {
47136       result = Dali::FrameBufferImage::New(*arg1);
47137     } catch (std::out_of_range& e) {
47138       {
47139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47140       };
47141     } catch (std::exception& e) {
47142       {
47143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47144       };
47145     } catch (Dali::DaliException e) {
47146       {
47147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47148       };
47149     } catch (...) {
47150       {
47151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47152       };
47153     }
47154   }
47155
47156   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47157   return jresult;
47158 }
47159
47160
47161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
47162   void * jresult ;
47163   Dali::BaseHandle arg1 ;
47164   Dali::BaseHandle *argp1 ;
47165   Dali::FrameBufferImage result;
47166
47167   argp1 = (Dali::BaseHandle *)jarg1;
47168   if (!argp1) {
47169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47170     return 0;
47171   }
47172   arg1 = *argp1;
47173   {
47174     try {
47175       result = Dali::FrameBufferImage::DownCast(arg1);
47176     } catch (std::out_of_range& e) {
47177       {
47178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47179       };
47180     } catch (std::exception& e) {
47181       {
47182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47183       };
47184     } catch (Dali::DaliException e) {
47185       {
47186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47187       };
47188     } catch (...) {
47189       {
47190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47191       };
47192     }
47193   }
47194
47195   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47196   return jresult;
47197 }
47198
47199
47200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
47201   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47202
47203   arg1 = (Dali::FrameBufferImage *)jarg1;
47204   {
47205     try {
47206       delete arg1;
47207     } catch (std::out_of_range& e) {
47208       {
47209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47210       };
47211     } catch (std::exception& e) {
47212       {
47213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47214       };
47215     } catch (Dali::DaliException e) {
47216       {
47217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47218       };
47219     } catch (...) {
47220       {
47221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47222       };
47223     }
47224   }
47225
47226 }
47227
47228
47229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
47230   void * jresult ;
47231   Dali::FrameBufferImage *arg1 = 0 ;
47232   Dali::FrameBufferImage *result = 0 ;
47233
47234   arg1 = (Dali::FrameBufferImage *)jarg1;
47235   if (!arg1) {
47236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47237     return 0;
47238   }
47239   {
47240     try {
47241       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
47242     } catch (std::out_of_range& e) {
47243       {
47244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47245       };
47246     } catch (std::exception& e) {
47247       {
47248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47249       };
47250     } catch (Dali::DaliException e) {
47251       {
47252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47253       };
47254     } catch (...) {
47255       {
47256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47257       };
47258     }
47259   }
47260
47261   jresult = (void *)result;
47262   return jresult;
47263 }
47264
47265
47266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
47267   void * jresult ;
47268   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47269   Dali::FrameBufferImage *arg2 = 0 ;
47270   Dali::FrameBufferImage *result = 0 ;
47271
47272   arg1 = (Dali::FrameBufferImage *)jarg1;
47273   arg2 = (Dali::FrameBufferImage *)jarg2;
47274   if (!arg2) {
47275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47276     return 0;
47277   }
47278   {
47279     try {
47280       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
47281     } catch (std::out_of_range& e) {
47282       {
47283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47284       };
47285     } catch (std::exception& e) {
47286       {
47287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47288       };
47289     } catch (Dali::DaliException e) {
47290       {
47291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47292       };
47293     } catch (...) {
47294       {
47295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47296       };
47297     }
47298   }
47299
47300   jresult = (void *)result;
47301   return jresult;
47302 }
47303
47304
47305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
47306   void * jresult ;
47307   Dali::NinePatchImage *result = 0 ;
47308
47309   {
47310     try {
47311       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
47312     } catch (std::out_of_range& e) {
47313       {
47314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47315       };
47316     } catch (std::exception& e) {
47317       {
47318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47319       };
47320     } catch (Dali::DaliException e) {
47321       {
47322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47323       };
47324     } catch (...) {
47325       {
47326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47327       };
47328     }
47329   }
47330
47331   jresult = (void *)result;
47332   return jresult;
47333 }
47334
47335
47336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
47337   void * jresult ;
47338   std::string *arg1 = 0 ;
47339   Dali::NinePatchImage result;
47340
47341   if (!jarg1) {
47342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47343     return 0;
47344   }
47345   std::string arg1_str(jarg1);
47346   arg1 = &arg1_str;
47347   {
47348     try {
47349       result = Dali::NinePatchImage::New((std::string const &)*arg1);
47350     } catch (std::out_of_range& e) {
47351       {
47352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47353       };
47354     } catch (std::exception& e) {
47355       {
47356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47357       };
47358     } catch (Dali::DaliException e) {
47359       {
47360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47361       };
47362     } catch (...) {
47363       {
47364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47365       };
47366     }
47367   }
47368
47369   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47370
47371   //argout typemap for const std::string&
47372
47373   return jresult;
47374 }
47375
47376
47377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
47378   void * jresult ;
47379   Dali::BaseHandle arg1 ;
47380   Dali::BaseHandle *argp1 ;
47381   Dali::NinePatchImage result;
47382
47383   argp1 = (Dali::BaseHandle *)jarg1;
47384   if (!argp1) {
47385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47386     return 0;
47387   }
47388   arg1 = *argp1;
47389   {
47390     try {
47391       result = Dali::NinePatchImage::DownCast(arg1);
47392     } catch (std::out_of_range& e) {
47393       {
47394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47395       };
47396     } catch (std::exception& e) {
47397       {
47398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47399       };
47400     } catch (Dali::DaliException e) {
47401       {
47402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47403       };
47404     } catch (...) {
47405       {
47406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47407       };
47408     }
47409   }
47410
47411   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47412   return jresult;
47413 }
47414
47415
47416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
47417   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47418
47419   arg1 = (Dali::NinePatchImage *)jarg1;
47420   {
47421     try {
47422       delete arg1;
47423     } catch (std::out_of_range& e) {
47424       {
47425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47426       };
47427     } catch (std::exception& e) {
47428       {
47429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47430       };
47431     } catch (Dali::DaliException e) {
47432       {
47433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47434       };
47435     } catch (...) {
47436       {
47437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47438       };
47439     }
47440   }
47441
47442 }
47443
47444
47445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
47446   void * jresult ;
47447   Dali::NinePatchImage *arg1 = 0 ;
47448   Dali::NinePatchImage *result = 0 ;
47449
47450   arg1 = (Dali::NinePatchImage *)jarg1;
47451   if (!arg1) {
47452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47453     return 0;
47454   }
47455   {
47456     try {
47457       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
47458     } catch (std::out_of_range& e) {
47459       {
47460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47461       };
47462     } catch (std::exception& e) {
47463       {
47464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47465       };
47466     } catch (Dali::DaliException e) {
47467       {
47468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47469       };
47470     } catch (...) {
47471       {
47472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47473       };
47474     }
47475   }
47476
47477   jresult = (void *)result;
47478   return jresult;
47479 }
47480
47481
47482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
47483   void * jresult ;
47484   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47485   Dali::NinePatchImage *arg2 = 0 ;
47486   Dali::NinePatchImage *result = 0 ;
47487
47488   arg1 = (Dali::NinePatchImage *)jarg1;
47489   arg2 = (Dali::NinePatchImage *)jarg2;
47490   if (!arg2) {
47491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47492     return 0;
47493   }
47494   {
47495     try {
47496       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
47497     } catch (std::out_of_range& e) {
47498       {
47499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47500       };
47501     } catch (std::exception& e) {
47502       {
47503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47504       };
47505     } catch (Dali::DaliException e) {
47506       {
47507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47508       };
47509     } catch (...) {
47510       {
47511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47512       };
47513     }
47514   }
47515
47516   jresult = (void *)result;
47517   return jresult;
47518 }
47519
47520
47521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
47522   void * jresult ;
47523   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47524   Dali::Vector4 result;
47525
47526   arg1 = (Dali::NinePatchImage *)jarg1;
47527   {
47528     try {
47529       result = (arg1)->GetStretchBorders();
47530     } catch (std::out_of_range& e) {
47531       {
47532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47533       };
47534     } catch (std::exception& e) {
47535       {
47536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47537       };
47538     } catch (Dali::DaliException e) {
47539       {
47540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47541       };
47542     } catch (...) {
47543       {
47544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47545       };
47546     }
47547   }
47548
47549   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
47550   return jresult;
47551 }
47552
47553
47554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
47555   void * jresult ;
47556   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47557   Dali::NinePatchImage::StretchRanges *result = 0 ;
47558
47559   arg1 = (Dali::NinePatchImage *)jarg1;
47560   {
47561     try {
47562       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
47563     } catch (std::out_of_range& e) {
47564       {
47565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47566       };
47567     } catch (std::exception& e) {
47568       {
47569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47570       };
47571     } catch (Dali::DaliException e) {
47572       {
47573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47574       };
47575     } catch (...) {
47576       {
47577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47578       };
47579     }
47580   }
47581
47582   jresult = (void *)result;
47583   return jresult;
47584 }
47585
47586
47587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
47588   void * jresult ;
47589   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47590   Dali::NinePatchImage::StretchRanges *result = 0 ;
47591
47592   arg1 = (Dali::NinePatchImage *)jarg1;
47593   {
47594     try {
47595       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
47596     } catch (std::out_of_range& e) {
47597       {
47598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47599       };
47600     } catch (std::exception& e) {
47601       {
47602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47603       };
47604     } catch (Dali::DaliException e) {
47605       {
47606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47607       };
47608     } catch (...) {
47609       {
47610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47611       };
47612     }
47613   }
47614
47615   jresult = (void *)result;
47616   return jresult;
47617 }
47618
47619
47620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
47621   void * jresult ;
47622   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47623   Dali::Rect< int > result;
47624
47625   arg1 = (Dali::NinePatchImage *)jarg1;
47626   {
47627     try {
47628       result = (arg1)->GetChildRectangle();
47629     } catch (std::out_of_range& e) {
47630       {
47631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47632       };
47633     } catch (std::exception& e) {
47634       {
47635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47636       };
47637     } catch (Dali::DaliException e) {
47638       {
47639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47640       };
47641     } catch (...) {
47642       {
47643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47644       };
47645     }
47646   }
47647
47648   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
47649   return jresult;
47650 }
47651
47652
47653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
47654   void * jresult ;
47655   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47656   Dali::BufferImage result;
47657
47658   arg1 = (Dali::NinePatchImage *)jarg1;
47659   {
47660     try {
47661       result = (arg1)->CreateCroppedBufferImage();
47662     } catch (std::out_of_range& e) {
47663       {
47664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47665       };
47666     } catch (std::exception& e) {
47667       {
47668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47669       };
47670     } catch (Dali::DaliException e) {
47671       {
47672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47673       };
47674     } catch (...) {
47675       {
47676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47677       };
47678     }
47679   }
47680
47681   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
47682   return jresult;
47683 }
47684
47685
47686 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
47687   unsigned int jresult ;
47688   std::string *arg1 = 0 ;
47689   bool result;
47690
47691   if (!jarg1) {
47692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47693     return 0;
47694   }
47695   std::string arg1_str(jarg1);
47696   arg1 = &arg1_str;
47697   {
47698     try {
47699       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
47700     } catch (std::out_of_range& e) {
47701       {
47702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47703       };
47704     } catch (std::exception& e) {
47705       {
47706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47707       };
47708     } catch (Dali::DaliException e) {
47709       {
47710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47711       };
47712     } catch (...) {
47713       {
47714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47715       };
47716     }
47717   }
47718
47719   jresult = result;
47720
47721   //argout typemap for const std::string&
47722
47723   return jresult;
47724 }
47725
47726
47727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
47728   int jresult ;
47729   int result;
47730
47731   result = (int)Dali::CameraActor::Property::TYPE;
47732   jresult = (int)result;
47733   return jresult;
47734 }
47735
47736
47737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
47738   int jresult ;
47739   int result;
47740
47741   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
47742   jresult = (int)result;
47743   return jresult;
47744 }
47745
47746
47747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
47748   int jresult ;
47749   int result;
47750
47751   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
47752   jresult = (int)result;
47753   return jresult;
47754 }
47755
47756
47757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
47758   int jresult ;
47759   int result;
47760
47761   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
47762   jresult = (int)result;
47763   return jresult;
47764 }
47765
47766
47767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
47768   int jresult ;
47769   int result;
47770
47771   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
47772   jresult = (int)result;
47773   return jresult;
47774 }
47775
47776
47777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
47778   int jresult ;
47779   int result;
47780
47781   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
47782   jresult = (int)result;
47783   return jresult;
47784 }
47785
47786
47787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
47788   int jresult ;
47789   int result;
47790
47791   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
47792   jresult = (int)result;
47793   return jresult;
47794 }
47795
47796
47797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
47798   int jresult ;
47799   int result;
47800
47801   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
47802   jresult = (int)result;
47803   return jresult;
47804 }
47805
47806
47807 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
47808   int jresult ;
47809   int result;
47810
47811   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
47812   jresult = (int)result;
47813   return jresult;
47814 }
47815
47816
47817 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
47818   int jresult ;
47819   int result;
47820
47821   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
47822   jresult = (int)result;
47823   return jresult;
47824 }
47825
47826
47827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
47828   int jresult ;
47829   int result;
47830
47831   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
47832   jresult = (int)result;
47833   return jresult;
47834 }
47835
47836
47837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
47838   int jresult ;
47839   int result;
47840
47841   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
47842   jresult = (int)result;
47843   return jresult;
47844 }
47845
47846
47847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
47848   int jresult ;
47849   int result;
47850
47851   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
47852   jresult = (int)result;
47853   return jresult;
47854 }
47855
47856
47857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
47858   int jresult ;
47859   int result;
47860
47861   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
47862   jresult = (int)result;
47863   return jresult;
47864 }
47865
47866
47867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
47868   void * jresult ;
47869   Dali::CameraActor::Property *result = 0 ;
47870
47871   {
47872     try {
47873       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
47874     } catch (std::out_of_range& e) {
47875       {
47876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47877       };
47878     } catch (std::exception& e) {
47879       {
47880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47881       };
47882     } catch (Dali::DaliException e) {
47883       {
47884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47885       };
47886     } catch (...) {
47887       {
47888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47889       };
47890     }
47891   }
47892
47893   jresult = (void *)result;
47894   return jresult;
47895 }
47896
47897
47898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
47899   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
47900
47901   arg1 = (Dali::CameraActor::Property *)jarg1;
47902   {
47903     try {
47904       delete arg1;
47905     } catch (std::out_of_range& e) {
47906       {
47907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47908       };
47909     } catch (std::exception& e) {
47910       {
47911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47912       };
47913     } catch (Dali::DaliException e) {
47914       {
47915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47916       };
47917     } catch (...) {
47918       {
47919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47920       };
47921     }
47922   }
47923
47924 }
47925
47926
47927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
47928   void * jresult ;
47929   Dali::CameraActor *result = 0 ;
47930
47931   {
47932     try {
47933       result = (Dali::CameraActor *)new Dali::CameraActor();
47934     } catch (std::out_of_range& e) {
47935       {
47936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47937       };
47938     } catch (std::exception& e) {
47939       {
47940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47941       };
47942     } catch (Dali::DaliException e) {
47943       {
47944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47945       };
47946     } catch (...) {
47947       {
47948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47949       };
47950     }
47951   }
47952
47953   jresult = (void *)result;
47954   return jresult;
47955 }
47956
47957
47958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
47959   void * jresult ;
47960   Dali::CameraActor result;
47961
47962   {
47963     try {
47964       result = Dali::CameraActor::New();
47965     } catch (std::out_of_range& e) {
47966       {
47967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47968       };
47969     } catch (std::exception& e) {
47970       {
47971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47972       };
47973     } catch (Dali::DaliException e) {
47974       {
47975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47976       };
47977     } catch (...) {
47978       {
47979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47980       };
47981     }
47982   }
47983
47984   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
47985   return jresult;
47986 }
47987
47988
47989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
47990   void * jresult ;
47991   Dali::Size *arg1 = 0 ;
47992   Dali::CameraActor result;
47993
47994   arg1 = (Dali::Size *)jarg1;
47995   if (!arg1) {
47996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
47997     return 0;
47998   }
47999   {
48000     try {
48001       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
48002     } catch (std::out_of_range& e) {
48003       {
48004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48005       };
48006     } catch (std::exception& e) {
48007       {
48008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48009       };
48010     } catch (Dali::DaliException e) {
48011       {
48012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48013       };
48014     } catch (...) {
48015       {
48016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48017       };
48018     }
48019   }
48020
48021   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48022   return jresult;
48023 }
48024
48025
48026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
48027   void * jresult ;
48028   Dali::BaseHandle arg1 ;
48029   Dali::BaseHandle *argp1 ;
48030   Dali::CameraActor result;
48031
48032   argp1 = (Dali::BaseHandle *)jarg1;
48033   if (!argp1) {
48034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48035     return 0;
48036   }
48037   arg1 = *argp1;
48038   {
48039     try {
48040       result = Dali::CameraActor::DownCast(arg1);
48041     } catch (std::out_of_range& e) {
48042       {
48043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48044       };
48045     } catch (std::exception& e) {
48046       {
48047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48048       };
48049     } catch (Dali::DaliException e) {
48050       {
48051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48052       };
48053     } catch (...) {
48054       {
48055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48056       };
48057     }
48058   }
48059
48060   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48061   return jresult;
48062 }
48063
48064
48065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
48066   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48067
48068   arg1 = (Dali::CameraActor *)jarg1;
48069   {
48070     try {
48071       delete arg1;
48072     } catch (std::out_of_range& e) {
48073       {
48074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48075       };
48076     } catch (std::exception& e) {
48077       {
48078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48079       };
48080     } catch (Dali::DaliException e) {
48081       {
48082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48083       };
48084     } catch (...) {
48085       {
48086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48087       };
48088     }
48089   }
48090
48091 }
48092
48093
48094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
48095   void * jresult ;
48096   Dali::CameraActor *arg1 = 0 ;
48097   Dali::CameraActor *result = 0 ;
48098
48099   arg1 = (Dali::CameraActor *)jarg1;
48100   if (!arg1) {
48101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48102     return 0;
48103   }
48104   {
48105     try {
48106       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
48107     } catch (std::out_of_range& e) {
48108       {
48109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48110       };
48111     } catch (std::exception& e) {
48112       {
48113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48114       };
48115     } catch (Dali::DaliException e) {
48116       {
48117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48118       };
48119     } catch (...) {
48120       {
48121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48122       };
48123     }
48124   }
48125
48126   jresult = (void *)result;
48127   return jresult;
48128 }
48129
48130
48131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
48132   void * jresult ;
48133   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48134   Dali::CameraActor *arg2 = 0 ;
48135   Dali::CameraActor *result = 0 ;
48136
48137   arg1 = (Dali::CameraActor *)jarg1;
48138   arg2 = (Dali::CameraActor *)jarg2;
48139   if (!arg2) {
48140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48141     return 0;
48142   }
48143   {
48144     try {
48145       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
48146     } catch (std::out_of_range& e) {
48147       {
48148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48149       };
48150     } catch (std::exception& e) {
48151       {
48152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48153       };
48154     } catch (Dali::DaliException e) {
48155       {
48156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48157       };
48158     } catch (...) {
48159       {
48160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48161       };
48162     }
48163   }
48164
48165   jresult = (void *)result;
48166   return jresult;
48167 }
48168
48169
48170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
48171   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48172   Dali::Camera::Type arg2 ;
48173
48174   arg1 = (Dali::CameraActor *)jarg1;
48175   arg2 = (Dali::Camera::Type)jarg2;
48176   {
48177     try {
48178       (arg1)->SetType(arg2);
48179     } catch (std::out_of_range& e) {
48180       {
48181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48182       };
48183     } catch (std::exception& e) {
48184       {
48185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48186       };
48187     } catch (Dali::DaliException e) {
48188       {
48189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48190       };
48191     } catch (...) {
48192       {
48193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48194       };
48195     }
48196   }
48197
48198 }
48199
48200
48201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
48202   int jresult ;
48203   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48204   Dali::Camera::Type result;
48205
48206   arg1 = (Dali::CameraActor *)jarg1;
48207   {
48208     try {
48209       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
48210     } catch (std::out_of_range& e) {
48211       {
48212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48213       };
48214     } catch (std::exception& e) {
48215       {
48216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48217       };
48218     } catch (Dali::DaliException e) {
48219       {
48220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48221       };
48222     } catch (...) {
48223       {
48224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48225       };
48226     }
48227   }
48228
48229   jresult = (int)result;
48230   return jresult;
48231 }
48232
48233
48234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
48235   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48236   Dali::Camera::ProjectionMode arg2 ;
48237
48238   arg1 = (Dali::CameraActor *)jarg1;
48239   arg2 = (Dali::Camera::ProjectionMode)jarg2;
48240   {
48241     try {
48242       (arg1)->SetProjectionMode(arg2);
48243     } catch (std::out_of_range& e) {
48244       {
48245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48246       };
48247     } catch (std::exception& e) {
48248       {
48249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48250       };
48251     } catch (Dali::DaliException e) {
48252       {
48253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48254       };
48255     } catch (...) {
48256       {
48257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48258       };
48259     }
48260   }
48261
48262 }
48263
48264
48265 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
48266   int jresult ;
48267   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48268   Dali::Camera::ProjectionMode result;
48269
48270   arg1 = (Dali::CameraActor *)jarg1;
48271   {
48272     try {
48273       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
48274     } catch (std::out_of_range& e) {
48275       {
48276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48277       };
48278     } catch (std::exception& e) {
48279       {
48280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48281       };
48282     } catch (Dali::DaliException e) {
48283       {
48284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48285       };
48286     } catch (...) {
48287       {
48288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48289       };
48290     }
48291   }
48292
48293   jresult = (int)result;
48294   return jresult;
48295 }
48296
48297
48298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
48299   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48300   float arg2 ;
48301
48302   arg1 = (Dali::CameraActor *)jarg1;
48303   arg2 = (float)jarg2;
48304   {
48305     try {
48306       (arg1)->SetFieldOfView(arg2);
48307     } catch (std::out_of_range& e) {
48308       {
48309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48310       };
48311     } catch (std::exception& e) {
48312       {
48313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48314       };
48315     } catch (Dali::DaliException e) {
48316       {
48317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48318       };
48319     } catch (...) {
48320       {
48321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48322       };
48323     }
48324   }
48325
48326 }
48327
48328
48329 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
48330   float jresult ;
48331   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48332   float result;
48333
48334   arg1 = (Dali::CameraActor *)jarg1;
48335   {
48336     try {
48337       result = (float)(arg1)->GetFieldOfView();
48338     } catch (std::out_of_range& e) {
48339       {
48340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48341       };
48342     } catch (std::exception& e) {
48343       {
48344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48345       };
48346     } catch (Dali::DaliException e) {
48347       {
48348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48349       };
48350     } catch (...) {
48351       {
48352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48353       };
48354     }
48355   }
48356
48357   jresult = result;
48358   return jresult;
48359 }
48360
48361
48362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
48363   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48364   float arg2 ;
48365
48366   arg1 = (Dali::CameraActor *)jarg1;
48367   arg2 = (float)jarg2;
48368   {
48369     try {
48370       (arg1)->SetAspectRatio(arg2);
48371     } catch (std::out_of_range& e) {
48372       {
48373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48374       };
48375     } catch (std::exception& e) {
48376       {
48377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48378       };
48379     } catch (Dali::DaliException e) {
48380       {
48381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48382       };
48383     } catch (...) {
48384       {
48385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48386       };
48387     }
48388   }
48389
48390 }
48391
48392
48393 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
48394   float jresult ;
48395   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48396   float result;
48397
48398   arg1 = (Dali::CameraActor *)jarg1;
48399   {
48400     try {
48401       result = (float)(arg1)->GetAspectRatio();
48402     } catch (std::out_of_range& e) {
48403       {
48404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48405       };
48406     } catch (std::exception& e) {
48407       {
48408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48409       };
48410     } catch (Dali::DaliException e) {
48411       {
48412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48413       };
48414     } catch (...) {
48415       {
48416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48417       };
48418     }
48419   }
48420
48421   jresult = result;
48422   return jresult;
48423 }
48424
48425
48426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
48427   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48428   float arg2 ;
48429
48430   arg1 = (Dali::CameraActor *)jarg1;
48431   arg2 = (float)jarg2;
48432   {
48433     try {
48434       (arg1)->SetNearClippingPlane(arg2);
48435     } catch (std::out_of_range& e) {
48436       {
48437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48438       };
48439     } catch (std::exception& e) {
48440       {
48441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48442       };
48443     } catch (Dali::DaliException e) {
48444       {
48445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48446       };
48447     } catch (...) {
48448       {
48449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48450       };
48451     }
48452   }
48453
48454 }
48455
48456
48457 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
48458   float jresult ;
48459   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48460   float result;
48461
48462   arg1 = (Dali::CameraActor *)jarg1;
48463   {
48464     try {
48465       result = (float)(arg1)->GetNearClippingPlane();
48466     } catch (std::out_of_range& e) {
48467       {
48468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48469       };
48470     } catch (std::exception& e) {
48471       {
48472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48473       };
48474     } catch (Dali::DaliException e) {
48475       {
48476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48477       };
48478     } catch (...) {
48479       {
48480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48481       };
48482     }
48483   }
48484
48485   jresult = result;
48486   return jresult;
48487 }
48488
48489
48490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
48491   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48492   float arg2 ;
48493
48494   arg1 = (Dali::CameraActor *)jarg1;
48495   arg2 = (float)jarg2;
48496   {
48497     try {
48498       (arg1)->SetFarClippingPlane(arg2);
48499     } catch (std::out_of_range& e) {
48500       {
48501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48502       };
48503     } catch (std::exception& e) {
48504       {
48505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48506       };
48507     } catch (Dali::DaliException e) {
48508       {
48509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48510       };
48511     } catch (...) {
48512       {
48513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48514       };
48515     }
48516   }
48517
48518 }
48519
48520
48521 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
48522   float jresult ;
48523   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48524   float result;
48525
48526   arg1 = (Dali::CameraActor *)jarg1;
48527   {
48528     try {
48529       result = (float)(arg1)->GetFarClippingPlane();
48530     } catch (std::out_of_range& e) {
48531       {
48532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48533       };
48534     } catch (std::exception& e) {
48535       {
48536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48537       };
48538     } catch (Dali::DaliException e) {
48539       {
48540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48541       };
48542     } catch (...) {
48543       {
48544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48545       };
48546     }
48547   }
48548
48549   jresult = result;
48550   return jresult;
48551 }
48552
48553
48554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
48555   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48556   Dali::Vector3 *arg2 = 0 ;
48557
48558   arg1 = (Dali::CameraActor *)jarg1;
48559   arg2 = (Dali::Vector3 *)jarg2;
48560   if (!arg2) {
48561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
48562     return ;
48563   }
48564   {
48565     try {
48566       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
48567     } catch (std::out_of_range& e) {
48568       {
48569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48570       };
48571     } catch (std::exception& e) {
48572       {
48573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48574       };
48575     } catch (Dali::DaliException e) {
48576       {
48577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48578       };
48579     } catch (...) {
48580       {
48581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48582       };
48583     }
48584   }
48585
48586 }
48587
48588
48589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
48590   void * jresult ;
48591   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48592   Dali::Vector3 result;
48593
48594   arg1 = (Dali::CameraActor *)jarg1;
48595   {
48596     try {
48597       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
48598     } catch (std::out_of_range& e) {
48599       {
48600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48601       };
48602     } catch (std::exception& e) {
48603       {
48604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48605       };
48606     } catch (Dali::DaliException e) {
48607       {
48608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48609       };
48610     } catch (...) {
48611       {
48612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48613       };
48614     }
48615   }
48616
48617   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
48618   return jresult;
48619 }
48620
48621
48622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
48623   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48624   bool arg2 ;
48625
48626   arg1 = (Dali::CameraActor *)jarg1;
48627   arg2 = jarg2 ? true : false;
48628   {
48629     try {
48630       (arg1)->SetInvertYAxis(arg2);
48631     } catch (std::out_of_range& e) {
48632       {
48633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48634       };
48635     } catch (std::exception& e) {
48636       {
48637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48638       };
48639     } catch (Dali::DaliException e) {
48640       {
48641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48642       };
48643     } catch (...) {
48644       {
48645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48646       };
48647     }
48648   }
48649
48650 }
48651
48652
48653 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
48654   unsigned int jresult ;
48655   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48656   bool result;
48657
48658   arg1 = (Dali::CameraActor *)jarg1;
48659   {
48660     try {
48661       result = (bool)(arg1)->GetInvertYAxis();
48662     } catch (std::out_of_range& e) {
48663       {
48664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48665       };
48666     } catch (std::exception& e) {
48667       {
48668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48669       };
48670     } catch (Dali::DaliException e) {
48671       {
48672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48673       };
48674     } catch (...) {
48675       {
48676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48677       };
48678     }
48679   }
48680
48681   jresult = result;
48682   return jresult;
48683 }
48684
48685
48686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
48687   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48688   Dali::Size *arg2 = 0 ;
48689
48690   arg1 = (Dali::CameraActor *)jarg1;
48691   arg2 = (Dali::Size *)jarg2;
48692   if (!arg2) {
48693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48694     return ;
48695   }
48696   {
48697     try {
48698       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
48699     } catch (std::out_of_range& e) {
48700       {
48701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48702       };
48703     } catch (std::exception& e) {
48704       {
48705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48706       };
48707     } catch (Dali::DaliException e) {
48708       {
48709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48710       };
48711     } catch (...) {
48712       {
48713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48714       };
48715     }
48716   }
48717
48718 }
48719
48720
48721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
48722   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48723   Dali::Size *arg2 = 0 ;
48724
48725   arg1 = (Dali::CameraActor *)jarg1;
48726   arg2 = (Dali::Size *)jarg2;
48727   if (!arg2) {
48728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48729     return ;
48730   }
48731   {
48732     try {
48733       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
48734     } catch (std::out_of_range& e) {
48735       {
48736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48737       };
48738     } catch (std::exception& e) {
48739       {
48740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48741       };
48742     } catch (Dali::DaliException e) {
48743       {
48744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48745       };
48746     } catch (...) {
48747       {
48748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48749       };
48750     }
48751   }
48752
48753 }
48754
48755
48756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
48757   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48758   float arg2 ;
48759   float arg3 ;
48760   float arg4 ;
48761   float arg5 ;
48762   float arg6 ;
48763   float arg7 ;
48764
48765   arg1 = (Dali::CameraActor *)jarg1;
48766   arg2 = (float)jarg2;
48767   arg3 = (float)jarg3;
48768   arg4 = (float)jarg4;
48769   arg5 = (float)jarg5;
48770   arg6 = (float)jarg6;
48771   arg7 = (float)jarg7;
48772   {
48773     try {
48774       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
48775     } catch (std::out_of_range& e) {
48776       {
48777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48778       };
48779     } catch (std::exception& e) {
48780       {
48781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48782       };
48783     } catch (Dali::DaliException e) {
48784       {
48785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48786       };
48787     } catch (...) {
48788       {
48789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48790       };
48791     }
48792   }
48793
48794 }
48795
48796
48797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
48798   void * jresult ;
48799   std::pair< std::string,Dali::Property::Value > *result = 0 ;
48800
48801   {
48802     try {
48803       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
48804     } catch (std::out_of_range& e) {
48805       {
48806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48807       };
48808     } catch (std::exception& e) {
48809       {
48810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48811       };
48812     } catch (Dali::DaliException e) {
48813       {
48814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48815       };
48816     } catch (...) {
48817       {
48818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48819       };
48820     }
48821   }
48822
48823   jresult = (void *)result;
48824   return jresult;
48825 }
48826
48827
48828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
48829   void * jresult ;
48830   std::string arg1 ;
48831   Dali::Property::Value arg2 ;
48832   Dali::Property::Value *argp2 ;
48833   std::pair< std::string,Dali::Property::Value > *result = 0 ;
48834
48835   if (!jarg1) {
48836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48837     return 0;
48838   }
48839   (&arg1)->assign(jarg1);
48840   argp2 = (Dali::Property::Value *)jarg2;
48841   if (!argp2) {
48842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
48843     return 0;
48844   }
48845   arg2 = *argp2;
48846   {
48847     try {
48848       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
48849     } catch (std::out_of_range& e) {
48850       {
48851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48852       };
48853     } catch (std::exception& e) {
48854       {
48855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48856       };
48857     } catch (Dali::DaliException e) {
48858       {
48859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48860       };
48861     } catch (...) {
48862       {
48863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48864       };
48865     }
48866   }
48867
48868   jresult = (void *)result;
48869   return jresult;
48870 }
48871
48872
48873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
48874   void * jresult ;
48875   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
48876   std::pair< std::string,Dali::Property::Value > *result = 0 ;
48877
48878   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
48879   if (!arg1) {
48880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
48881     return 0;
48882   }
48883   {
48884     try {
48885       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);
48886     } catch (std::out_of_range& e) {
48887       {
48888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48889       };
48890     } catch (std::exception& e) {
48891       {
48892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48893       };
48894     } catch (Dali::DaliException e) {
48895       {
48896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48897       };
48898     } catch (...) {
48899       {
48900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48901       };
48902     }
48903   }
48904
48905   jresult = (void *)result;
48906   return jresult;
48907 }
48908
48909
48910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
48911   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
48912   std::string *arg2 = 0 ;
48913
48914   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
48915   if (!jarg2) {
48916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48917     return ;
48918   }
48919   std::string arg2_str(jarg2);
48920   arg2 = &arg2_str;
48921   if (arg1) (arg1)->first = *arg2;
48922
48923   //argout typemap for const std::string&
48924
48925 }
48926
48927
48928 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
48929   char * jresult ;
48930   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
48931   std::string *result = 0 ;
48932
48933   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
48934   result = (std::string *) & ((arg1)->first);
48935   jresult = SWIG_csharp_string_callback(result->c_str());
48936   return jresult;
48937 }
48938
48939
48940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
48941   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
48942   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
48943
48944   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
48945   arg2 = (Dali::Property::Value *)jarg2;
48946   if (arg1) (arg1)->second = *arg2;
48947 }
48948
48949
48950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
48951   void * jresult ;
48952   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
48953   Dali::Property::Value *result = 0 ;
48954
48955   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
48956   result = (Dali::Property::Value *)& ((arg1)->second);
48957   jresult = (void *)result;
48958   return jresult;
48959 }
48960
48961
48962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
48963   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
48964
48965   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
48966   {
48967     try {
48968       delete arg1;
48969     } catch (std::out_of_range& e) {
48970       {
48971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48972       };
48973     } catch (std::exception& e) {
48974       {
48975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48976       };
48977     } catch (Dali::DaliException e) {
48978       {
48979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48980       };
48981     } catch (...) {
48982       {
48983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48984       };
48985     }
48986   }
48987
48988 }
48989
48990
48991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
48992   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
48993
48994   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
48995   {
48996     try {
48997       (arg1)->clear();
48998     } catch (std::out_of_range& e) {
48999       {
49000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49001       };
49002     } catch (std::exception& e) {
49003       {
49004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49005       };
49006     } catch (Dali::DaliException e) {
49007       {
49008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49009       };
49010     } catch (...) {
49011       {
49012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49013       };
49014     }
49015   }
49016
49017 }
49018
49019
49020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
49021   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49022   Dali::TouchPoint *arg2 = 0 ;
49023
49024   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49025   arg2 = (Dali::TouchPoint *)jarg2;
49026   if (!arg2) {
49027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49028     return ;
49029   }
49030   {
49031     try {
49032       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
49033     } catch (std::out_of_range& e) {
49034       {
49035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49036       };
49037     } catch (std::exception& e) {
49038       {
49039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49040       };
49041     } catch (Dali::DaliException e) {
49042       {
49043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49044       };
49045     } catch (...) {
49046       {
49047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49048       };
49049     }
49050   }
49051
49052 }
49053
49054
49055 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
49056   unsigned long jresult ;
49057   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49058   std::vector< Dali::TouchPoint >::size_type result;
49059
49060   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49061   {
49062     try {
49063       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
49064     } catch (std::out_of_range& e) {
49065       {
49066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49067       };
49068     } catch (std::exception& e) {
49069       {
49070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49071       };
49072     } catch (Dali::DaliException e) {
49073       {
49074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49075       };
49076     } catch (...) {
49077       {
49078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49079       };
49080     }
49081   }
49082
49083   jresult = (unsigned long)result;
49084   return jresult;
49085 }
49086
49087
49088 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
49089   unsigned long jresult ;
49090   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49091   std::vector< Dali::TouchPoint >::size_type result;
49092
49093   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49094   {
49095     try {
49096       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
49097     } catch (std::out_of_range& e) {
49098       {
49099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49100       };
49101     } catch (std::exception& e) {
49102       {
49103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49104       };
49105     } catch (Dali::DaliException e) {
49106       {
49107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49108       };
49109     } catch (...) {
49110       {
49111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49112       };
49113     }
49114   }
49115
49116   jresult = (unsigned long)result;
49117   return jresult;
49118 }
49119
49120
49121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
49122   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49123   std::vector< Dali::TouchPoint >::size_type arg2 ;
49124
49125   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49126   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
49127   {
49128     try {
49129       (arg1)->reserve(arg2);
49130     } catch (std::out_of_range& e) {
49131       {
49132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49133       };
49134     } catch (std::exception& e) {
49135       {
49136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49137       };
49138     } catch (Dali::DaliException e) {
49139       {
49140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49141       };
49142     } catch (...) {
49143       {
49144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49145       };
49146     }
49147   }
49148
49149 }
49150
49151
49152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
49153   void * jresult ;
49154   std::vector< Dali::TouchPoint > *result = 0 ;
49155
49156   {
49157     try {
49158       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
49159     } catch (std::out_of_range& e) {
49160       {
49161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49162       };
49163     } catch (std::exception& e) {
49164       {
49165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49166       };
49167     } catch (Dali::DaliException e) {
49168       {
49169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49170       };
49171     } catch (...) {
49172       {
49173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49174       };
49175     }
49176   }
49177
49178   jresult = (void *)result;
49179   return jresult;
49180 }
49181
49182
49183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
49184   void * jresult ;
49185   std::vector< Dali::TouchPoint > *arg1 = 0 ;
49186   std::vector< Dali::TouchPoint > *result = 0 ;
49187
49188   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49189   if (!arg1) {
49190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49191     return 0;
49192   }
49193   {
49194     try {
49195       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
49196     } catch (std::out_of_range& e) {
49197       {
49198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49199       };
49200     } catch (std::exception& e) {
49201       {
49202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49203       };
49204     } catch (Dali::DaliException e) {
49205       {
49206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49207       };
49208     } catch (...) {
49209       {
49210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49211       };
49212     }
49213   }
49214
49215   jresult = (void *)result;
49216   return jresult;
49217 }
49218
49219
49220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
49221   void * jresult ;
49222   int arg1 ;
49223   std::vector< Dali::TouchPoint > *result = 0 ;
49224
49225   arg1 = (int)jarg1;
49226   {
49227     try {
49228       try {
49229         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
49230       }
49231       catch(std::out_of_range &_e) {
49232         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49233         return 0;
49234       }
49235
49236     } catch (std::out_of_range& e) {
49237       {
49238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49239       };
49240     } catch (std::exception& e) {
49241       {
49242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49243       };
49244     } catch (Dali::DaliException e) {
49245       {
49246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49247       };
49248     } catch (...) {
49249       {
49250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49251       };
49252     }
49253   }
49254
49255   jresult = (void *)result;
49256   return jresult;
49257 }
49258
49259
49260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
49261   void * jresult ;
49262   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49263   int arg2 ;
49264   SwigValueWrapper< Dali::TouchPoint > result;
49265
49266   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49267   arg2 = (int)jarg2;
49268   {
49269     try {
49270       try {
49271         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
49272       }
49273       catch(std::out_of_range &_e) {
49274         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49275         return 0;
49276       }
49277
49278     } catch (std::out_of_range& e) {
49279       {
49280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49281       };
49282     } catch (std::exception& e) {
49283       {
49284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49285       };
49286     } catch (Dali::DaliException e) {
49287       {
49288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49289       };
49290     } catch (...) {
49291       {
49292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49293       };
49294     }
49295   }
49296
49297   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
49298   return jresult;
49299 }
49300
49301
49302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
49303   void * jresult ;
49304   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49305   int arg2 ;
49306   Dali::TouchPoint *result = 0 ;
49307
49308   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49309   arg2 = (int)jarg2;
49310   {
49311     try {
49312       try {
49313         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
49314       }
49315       catch(std::out_of_range &_e) {
49316         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49317         return 0;
49318       }
49319
49320     } catch (std::out_of_range& e) {
49321       {
49322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49323       };
49324     } catch (std::exception& e) {
49325       {
49326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49327       };
49328     } catch (Dali::DaliException e) {
49329       {
49330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49331       };
49332     } catch (...) {
49333       {
49334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49335       };
49336     }
49337   }
49338
49339   jresult = (void *)result;
49340   return jresult;
49341 }
49342
49343
49344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
49345   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49346   int arg2 ;
49347   Dali::TouchPoint *arg3 = 0 ;
49348
49349   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49350   arg2 = (int)jarg2;
49351   arg3 = (Dali::TouchPoint *)jarg3;
49352   if (!arg3) {
49353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49354     return ;
49355   }
49356   {
49357     try {
49358       try {
49359         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49360       }
49361       catch(std::out_of_range &_e) {
49362         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49363         return ;
49364       }
49365
49366     } catch (std::out_of_range& e) {
49367       {
49368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49369       };
49370     } catch (std::exception& e) {
49371       {
49372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49373       };
49374     } catch (Dali::DaliException e) {
49375       {
49376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49377       };
49378     } catch (...) {
49379       {
49380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49381       };
49382     }
49383   }
49384
49385 }
49386
49387
49388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
49389   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49390   std::vector< Dali::TouchPoint > *arg2 = 0 ;
49391
49392   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49393   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
49394   if (!arg2) {
49395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49396     return ;
49397   }
49398   {
49399     try {
49400       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
49401     } catch (std::out_of_range& e) {
49402       {
49403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49404       };
49405     } catch (std::exception& e) {
49406       {
49407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49408       };
49409     } catch (Dali::DaliException e) {
49410       {
49411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49412       };
49413     } catch (...) {
49414       {
49415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49416       };
49417     }
49418   }
49419
49420 }
49421
49422
49423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
49424   void * jresult ;
49425   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49426   int arg2 ;
49427   int arg3 ;
49428   std::vector< Dali::TouchPoint > *result = 0 ;
49429
49430   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49431   arg2 = (int)jarg2;
49432   arg3 = (int)jarg3;
49433   {
49434     try {
49435       try {
49436         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
49437       }
49438       catch(std::out_of_range &_e) {
49439         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49440         return 0;
49441       }
49442       catch(std::invalid_argument &_e) {
49443         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49444         return 0;
49445       }
49446
49447     } catch (std::out_of_range& e) {
49448       {
49449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49450       };
49451     } catch (std::exception& e) {
49452       {
49453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49454       };
49455     } catch (Dali::DaliException e) {
49456       {
49457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49458       };
49459     } catch (...) {
49460       {
49461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49462       };
49463     }
49464   }
49465
49466   jresult = (void *)result;
49467   return jresult;
49468 }
49469
49470
49471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
49472   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49473   int arg2 ;
49474   Dali::TouchPoint *arg3 = 0 ;
49475
49476   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49477   arg2 = (int)jarg2;
49478   arg3 = (Dali::TouchPoint *)jarg3;
49479   if (!arg3) {
49480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49481     return ;
49482   }
49483   {
49484     try {
49485       try {
49486         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49487       }
49488       catch(std::out_of_range &_e) {
49489         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49490         return ;
49491       }
49492
49493     } catch (std::out_of_range& e) {
49494       {
49495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49496       };
49497     } catch (std::exception& e) {
49498       {
49499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49500       };
49501     } catch (Dali::DaliException e) {
49502       {
49503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49504       };
49505     } catch (...) {
49506       {
49507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49508       };
49509     }
49510   }
49511
49512 }
49513
49514
49515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
49516   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49517   int arg2 ;
49518   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49519
49520   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49521   arg2 = (int)jarg2;
49522   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49523   if (!arg3) {
49524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49525     return ;
49526   }
49527   {
49528     try {
49529       try {
49530         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49531       }
49532       catch(std::out_of_range &_e) {
49533         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49534         return ;
49535       }
49536
49537     } catch (std::out_of_range& e) {
49538       {
49539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49540       };
49541     } catch (std::exception& e) {
49542       {
49543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49544       };
49545     } catch (Dali::DaliException e) {
49546       {
49547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49548       };
49549     } catch (...) {
49550       {
49551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49552       };
49553     }
49554   }
49555
49556 }
49557
49558
49559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
49560   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49561   int arg2 ;
49562
49563   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49564   arg2 = (int)jarg2;
49565   {
49566     try {
49567       try {
49568         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
49569       }
49570       catch(std::out_of_range &_e) {
49571         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49572         return ;
49573       }
49574
49575     } catch (std::out_of_range& e) {
49576       {
49577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49578       };
49579     } catch (std::exception& e) {
49580       {
49581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49582       };
49583     } catch (Dali::DaliException e) {
49584       {
49585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49586       };
49587     } catch (...) {
49588       {
49589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49590       };
49591     }
49592   }
49593
49594 }
49595
49596
49597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
49598   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49599   int arg2 ;
49600   int arg3 ;
49601
49602   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49603   arg2 = (int)jarg2;
49604   arg3 = (int)jarg3;
49605   {
49606     try {
49607       try {
49608         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
49609       }
49610       catch(std::out_of_range &_e) {
49611         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49612         return ;
49613       }
49614       catch(std::invalid_argument &_e) {
49615         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49616         return ;
49617       }
49618
49619     } catch (std::out_of_range& e) {
49620       {
49621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49622       };
49623     } catch (std::exception& e) {
49624       {
49625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49626       };
49627     } catch (Dali::DaliException e) {
49628       {
49629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49630       };
49631     } catch (...) {
49632       {
49633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49634       };
49635     }
49636   }
49637
49638 }
49639
49640
49641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
49642   void * jresult ;
49643   Dali::TouchPoint *arg1 = 0 ;
49644   int arg2 ;
49645   std::vector< Dali::TouchPoint > *result = 0 ;
49646
49647   arg1 = (Dali::TouchPoint *)jarg1;
49648   if (!arg1) {
49649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49650     return 0;
49651   }
49652   arg2 = (int)jarg2;
49653   {
49654     try {
49655       try {
49656         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
49657       }
49658       catch(std::out_of_range &_e) {
49659         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49660         return 0;
49661       }
49662
49663     } catch (std::out_of_range& e) {
49664       {
49665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49666       };
49667     } catch (std::exception& e) {
49668       {
49669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49670       };
49671     } catch (Dali::DaliException e) {
49672       {
49673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49674       };
49675     } catch (...) {
49676       {
49677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49678       };
49679     }
49680   }
49681
49682   jresult = (void *)result;
49683   return jresult;
49684 }
49685
49686
49687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
49688   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49689
49690   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49691   {
49692     try {
49693       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
49694     } catch (std::out_of_range& e) {
49695       {
49696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49697       };
49698     } catch (std::exception& e) {
49699       {
49700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49701       };
49702     } catch (Dali::DaliException e) {
49703       {
49704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49705       };
49706     } catch (...) {
49707       {
49708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49709       };
49710     }
49711   }
49712
49713 }
49714
49715
49716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
49717   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49718   int arg2 ;
49719   int arg3 ;
49720
49721   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49722   arg2 = (int)jarg2;
49723   arg3 = (int)jarg3;
49724   {
49725     try {
49726       try {
49727         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
49728       }
49729       catch(std::out_of_range &_e) {
49730         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49731         return ;
49732       }
49733       catch(std::invalid_argument &_e) {
49734         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49735         return ;
49736       }
49737
49738     } catch (std::out_of_range& e) {
49739       {
49740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49741       };
49742     } catch (std::exception& e) {
49743       {
49744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49745       };
49746     } catch (Dali::DaliException e) {
49747       {
49748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49749       };
49750     } catch (...) {
49751       {
49752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49753       };
49754     }
49755   }
49756
49757 }
49758
49759
49760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
49761   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49762   int arg2 ;
49763   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49764
49765   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49766   arg2 = (int)jarg2;
49767   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49768   if (!arg3) {
49769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49770     return ;
49771   }
49772   {
49773     try {
49774       try {
49775         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49776       }
49777       catch(std::out_of_range &_e) {
49778         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49779         return ;
49780       }
49781
49782     } catch (std::out_of_range& e) {
49783       {
49784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49785       };
49786     } catch (std::exception& e) {
49787       {
49788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49789       };
49790     } catch (Dali::DaliException e) {
49791       {
49792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49793       };
49794     } catch (...) {
49795       {
49796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49797       };
49798     }
49799   }
49800
49801 }
49802
49803
49804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
49805   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49806
49807   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49808   {
49809     try {
49810       delete arg1;
49811     } catch (std::out_of_range& e) {
49812       {
49813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49814       };
49815     } catch (std::exception& e) {
49816       {
49817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49818       };
49819     } catch (Dali::DaliException e) {
49820       {
49821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49822       };
49823     } catch (...) {
49824       {
49825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49826       };
49827     }
49828   }
49829
49830 }
49831
49832
49833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
49834   void * jresult ;
49835   Dali::Rect< int > *result = 0 ;
49836
49837   {
49838     try {
49839       result = (Dali::Rect< int > *)new Dali::Rect< int >();
49840     } catch (std::out_of_range& e) {
49841       {
49842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49843       };
49844     } catch (std::exception& e) {
49845       {
49846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49847       };
49848     } catch (Dali::DaliException e) {
49849       {
49850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49851       };
49852     } catch (...) {
49853       {
49854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49855       };
49856     }
49857   }
49858
49859   jresult = (void *)result;
49860   return jresult;
49861 }
49862
49863
49864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
49865   void * jresult ;
49866   int arg1 ;
49867   int arg2 ;
49868   int arg3 ;
49869   int arg4 ;
49870   Dali::Rect< int > *result = 0 ;
49871
49872   arg1 = (int)jarg1;
49873   arg2 = (int)jarg2;
49874   arg3 = (int)jarg3;
49875   arg4 = (int)jarg4;
49876   {
49877     try {
49878       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
49879     } catch (std::out_of_range& e) {
49880       {
49881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49882       };
49883     } catch (std::exception& e) {
49884       {
49885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49886       };
49887     } catch (Dali::DaliException e) {
49888       {
49889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49890       };
49891     } catch (...) {
49892       {
49893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49894       };
49895     }
49896   }
49897
49898   jresult = (void *)result;
49899   return jresult;
49900 }
49901
49902
49903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
49904   void * jresult ;
49905   Dali::Rect< int > *arg1 = 0 ;
49906   Dali::Rect< int > *result = 0 ;
49907
49908   arg1 = (Dali::Rect< int > *)jarg1;
49909   if (!arg1) {
49910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
49911     return 0;
49912   }
49913   {
49914     try {
49915       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
49916     } catch (std::out_of_range& e) {
49917       {
49918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49919       };
49920     } catch (std::exception& e) {
49921       {
49922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49923       };
49924     } catch (Dali::DaliException e) {
49925       {
49926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49927       };
49928     } catch (...) {
49929       {
49930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49931       };
49932     }
49933   }
49934
49935   jresult = (void *)result;
49936   return jresult;
49937 }
49938
49939
49940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
49941   void * jresult ;
49942   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
49943   Dali::Rect< int > *arg2 = 0 ;
49944   Dali::Rect< int > *result = 0 ;
49945
49946   arg1 = (Dali::Rect< int > *)jarg1;
49947   arg2 = (Dali::Rect< int > *)jarg2;
49948   if (!arg2) {
49949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
49950     return 0;
49951   }
49952   {
49953     try {
49954       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
49955     } catch (std::out_of_range& e) {
49956       {
49957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49958       };
49959     } catch (std::exception& e) {
49960       {
49961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49962       };
49963     } catch (Dali::DaliException e) {
49964       {
49965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49966       };
49967     } catch (...) {
49968       {
49969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49970       };
49971     }
49972   }
49973
49974   jresult = (void *)result;
49975   return jresult;
49976 }
49977
49978
49979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
49980   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
49981   int arg2 ;
49982   int arg3 ;
49983   int arg4 ;
49984   int arg5 ;
49985
49986   arg1 = (Dali::Rect< int > *)jarg1;
49987   arg2 = (int)jarg2;
49988   arg3 = (int)jarg3;
49989   arg4 = (int)jarg4;
49990   arg5 = (int)jarg5;
49991   {
49992     try {
49993       (arg1)->Set(arg2,arg3,arg4,arg5);
49994     } catch (std::out_of_range& e) {
49995       {
49996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49997       };
49998     } catch (std::exception& e) {
49999       {
50000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50001       };
50002     } catch (Dali::DaliException e) {
50003       {
50004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50005       };
50006     } catch (...) {
50007       {
50008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50009       };
50010     }
50011   }
50012
50013 }
50014
50015
50016 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
50017   unsigned int jresult ;
50018   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50019   bool result;
50020
50021   arg1 = (Dali::Rect< int > *)jarg1;
50022   {
50023     try {
50024       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
50025     } catch (std::out_of_range& e) {
50026       {
50027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50028       };
50029     } catch (std::exception& e) {
50030       {
50031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50032       };
50033     } catch (Dali::DaliException e) {
50034       {
50035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50036       };
50037     } catch (...) {
50038       {
50039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50040       };
50041     }
50042   }
50043
50044   jresult = result;
50045   return jresult;
50046 }
50047
50048
50049 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
50050   int jresult ;
50051   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50052   int result;
50053
50054   arg1 = (Dali::Rect< int > *)jarg1;
50055   {
50056     try {
50057       result = (int)((Dali::Rect< int > const *)arg1)->Left();
50058     } catch (std::out_of_range& e) {
50059       {
50060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50061       };
50062     } catch (std::exception& e) {
50063       {
50064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50065       };
50066     } catch (Dali::DaliException e) {
50067       {
50068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50069       };
50070     } catch (...) {
50071       {
50072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50073       };
50074     }
50075   }
50076
50077   jresult = result;
50078   return jresult;
50079 }
50080
50081
50082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
50083   int jresult ;
50084   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50085   int result;
50086
50087   arg1 = (Dali::Rect< int > *)jarg1;
50088   {
50089     try {
50090       result = (int)((Dali::Rect< int > const *)arg1)->Right();
50091     } catch (std::out_of_range& e) {
50092       {
50093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50094       };
50095     } catch (std::exception& e) {
50096       {
50097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50098       };
50099     } catch (Dali::DaliException e) {
50100       {
50101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50102       };
50103     } catch (...) {
50104       {
50105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50106       };
50107     }
50108   }
50109
50110   jresult = result;
50111   return jresult;
50112 }
50113
50114
50115 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
50116   int jresult ;
50117   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50118   int result;
50119
50120   arg1 = (Dali::Rect< int > *)jarg1;
50121   {
50122     try {
50123       result = (int)((Dali::Rect< int > const *)arg1)->Top();
50124     } catch (std::out_of_range& e) {
50125       {
50126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50127       };
50128     } catch (std::exception& e) {
50129       {
50130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50131       };
50132     } catch (Dali::DaliException e) {
50133       {
50134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50135       };
50136     } catch (...) {
50137       {
50138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50139       };
50140     }
50141   }
50142
50143   jresult = result;
50144   return jresult;
50145 }
50146
50147
50148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
50149   int jresult ;
50150   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50151   int result;
50152
50153   arg1 = (Dali::Rect< int > *)jarg1;
50154   {
50155     try {
50156       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
50157     } catch (std::out_of_range& e) {
50158       {
50159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50160       };
50161     } catch (std::exception& e) {
50162       {
50163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50164       };
50165     } catch (Dali::DaliException e) {
50166       {
50167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50168       };
50169     } catch (...) {
50170       {
50171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50172       };
50173     }
50174   }
50175
50176   jresult = result;
50177   return jresult;
50178 }
50179
50180
50181 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
50182   int jresult ;
50183   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50184   int result;
50185
50186   arg1 = (Dali::Rect< int > *)jarg1;
50187   {
50188     try {
50189       result = (int)((Dali::Rect< int > const *)arg1)->Area();
50190     } catch (std::out_of_range& e) {
50191       {
50192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50193       };
50194     } catch (std::exception& e) {
50195       {
50196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50197       };
50198     } catch (Dali::DaliException e) {
50199       {
50200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50201       };
50202     } catch (...) {
50203       {
50204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50205       };
50206     }
50207   }
50208
50209   jresult = result;
50210   return jresult;
50211 }
50212
50213
50214 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
50215   unsigned int jresult ;
50216   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50217   Dali::Rect< int > *arg2 = 0 ;
50218   bool result;
50219
50220   arg1 = (Dali::Rect< int > *)jarg1;
50221   arg2 = (Dali::Rect< int > *)jarg2;
50222   if (!arg2) {
50223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50224     return 0;
50225   }
50226   {
50227     try {
50228       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
50229     } catch (std::out_of_range& e) {
50230       {
50231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50232       };
50233     } catch (std::exception& e) {
50234       {
50235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50236       };
50237     } catch (Dali::DaliException e) {
50238       {
50239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50240       };
50241     } catch (...) {
50242       {
50243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50244       };
50245     }
50246   }
50247
50248   jresult = result;
50249   return jresult;
50250 }
50251
50252
50253 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
50254   unsigned int jresult ;
50255   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50256   Dali::Rect< int > *arg2 = 0 ;
50257   bool result;
50258
50259   arg1 = (Dali::Rect< int > *)jarg1;
50260   arg2 = (Dali::Rect< int > *)jarg2;
50261   if (!arg2) {
50262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50263     return 0;
50264   }
50265   {
50266     try {
50267       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
50268     } catch (std::out_of_range& e) {
50269       {
50270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50271       };
50272     } catch (std::exception& e) {
50273       {
50274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50275       };
50276     } catch (Dali::DaliException e) {
50277       {
50278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50279       };
50280     } catch (...) {
50281       {
50282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50283       };
50284     }
50285   }
50286
50287   jresult = result;
50288   return jresult;
50289 }
50290
50291
50292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
50293   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50294   int arg2 ;
50295
50296   arg1 = (Dali::Rect< int > *)jarg1;
50297   arg2 = (int)jarg2;
50298   if (arg1) (arg1)->x = arg2;
50299 }
50300
50301
50302 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
50303   int jresult ;
50304   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50305   int result;
50306
50307   arg1 = (Dali::Rect< int > *)jarg1;
50308   result = (int) ((arg1)->x);
50309   jresult = result;
50310   return jresult;
50311 }
50312
50313
50314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
50315   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50316   int arg2 ;
50317
50318   arg1 = (Dali::Rect< int > *)jarg1;
50319   arg2 = (int)jarg2;
50320   if (arg1) (arg1)->left = arg2;
50321 }
50322
50323
50324 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
50325   int jresult ;
50326   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50327   int result;
50328
50329   arg1 = (Dali::Rect< int > *)jarg1;
50330   result = (int) ((arg1)->left);
50331   jresult = result;
50332   return jresult;
50333 }
50334
50335
50336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
50337   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50338   int arg2 ;
50339
50340   arg1 = (Dali::Rect< int > *)jarg1;
50341   arg2 = (int)jarg2;
50342   if (arg1) (arg1)->y = arg2;
50343 }
50344
50345
50346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
50347   int jresult ;
50348   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50349   int result;
50350
50351   arg1 = (Dali::Rect< int > *)jarg1;
50352   result = (int) ((arg1)->y);
50353   jresult = result;
50354   return jresult;
50355 }
50356
50357
50358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
50359   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50360   int arg2 ;
50361
50362   arg1 = (Dali::Rect< int > *)jarg1;
50363   arg2 = (int)jarg2;
50364   if (arg1) (arg1)->right = arg2;
50365 }
50366
50367
50368 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
50369   int jresult ;
50370   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50371   int result;
50372
50373   arg1 = (Dali::Rect< int > *)jarg1;
50374   result = (int) ((arg1)->right);
50375   jresult = result;
50376   return jresult;
50377 }
50378
50379
50380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
50381   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50382   int arg2 ;
50383
50384   arg1 = (Dali::Rect< int > *)jarg1;
50385   arg2 = (int)jarg2;
50386   if (arg1) (arg1)->width = arg2;
50387 }
50388
50389
50390 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
50391   int jresult ;
50392   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50393   int result;
50394
50395   arg1 = (Dali::Rect< int > *)jarg1;
50396   result = (int) ((arg1)->width);
50397   jresult = result;
50398   return jresult;
50399 }
50400
50401
50402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
50403   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50404   int arg2 ;
50405
50406   arg1 = (Dali::Rect< int > *)jarg1;
50407   arg2 = (int)jarg2;
50408   if (arg1) (arg1)->bottom = arg2;
50409 }
50410
50411
50412 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
50413   int jresult ;
50414   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50415   int result;
50416
50417   arg1 = (Dali::Rect< int > *)jarg1;
50418   result = (int) ((arg1)->bottom);
50419   jresult = result;
50420   return jresult;
50421 }
50422
50423
50424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
50425   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50426   int arg2 ;
50427
50428   arg1 = (Dali::Rect< int > *)jarg1;
50429   arg2 = (int)jarg2;
50430   if (arg1) (arg1)->height = arg2;
50431 }
50432
50433
50434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
50435   int jresult ;
50436   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50437   int result;
50438
50439   arg1 = (Dali::Rect< int > *)jarg1;
50440   result = (int) ((arg1)->height);
50441   jresult = result;
50442   return jresult;
50443 }
50444
50445
50446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
50447   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50448   int arg2 ;
50449
50450   arg1 = (Dali::Rect< int > *)jarg1;
50451   arg2 = (int)jarg2;
50452   if (arg1) (arg1)->top = arg2;
50453 }
50454
50455
50456 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
50457   int jresult ;
50458   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50459   int result;
50460
50461   arg1 = (Dali::Rect< int > *)jarg1;
50462   result = (int) ((arg1)->top);
50463   jresult = result;
50464   return jresult;
50465 }
50466
50467
50468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
50469   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50470
50471   arg1 = (Dali::Rect< int > *)jarg1;
50472   {
50473     try {
50474       delete arg1;
50475     } catch (std::out_of_range& e) {
50476       {
50477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50478       };
50479     } catch (std::exception& e) {
50480       {
50481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50482       };
50483     } catch (Dali::DaliException e) {
50484       {
50485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50486       };
50487     } catch (...) {
50488       {
50489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50490       };
50491     }
50492   }
50493
50494 }
50495
50496
50497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
50498   void * jresult ;
50499   Dali::Rect< float > *result = 0 ;
50500
50501   {
50502     try {
50503       result = (Dali::Rect< float > *)new Dali::Rect< float >();
50504     } catch (std::out_of_range& e) {
50505       {
50506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50507       };
50508     } catch (std::exception& e) {
50509       {
50510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50511       };
50512     } catch (Dali::DaliException e) {
50513       {
50514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50515       };
50516     } catch (...) {
50517       {
50518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50519       };
50520     }
50521   }
50522
50523   jresult = (void *)result;
50524   return jresult;
50525 }
50526
50527
50528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
50529   void * jresult ;
50530   float arg1 ;
50531   float arg2 ;
50532   float arg3 ;
50533   float arg4 ;
50534   Dali::Rect< float > *result = 0 ;
50535
50536   arg1 = (float)jarg1;
50537   arg2 = (float)jarg2;
50538   arg3 = (float)jarg4;
50539   arg4 = (float)jarg3;
50540   {
50541     try {
50542       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
50543     } catch (std::out_of_range& e) {
50544       {
50545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50546       };
50547     } catch (std::exception& e) {
50548       {
50549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50550       };
50551     } catch (Dali::DaliException e) {
50552       {
50553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50554       };
50555     } catch (...) {
50556       {
50557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50558       };
50559     }
50560   }
50561
50562   jresult = (void *)result;
50563   return jresult;
50564 }
50565
50566
50567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
50568   void * jresult ;
50569   Dali::Rect< float > *arg1 = 0 ;
50570   Dali::Rect< float > *result = 0 ;
50571
50572   arg1 = (Dali::Rect< float > *)jarg1;
50573   if (!arg1) {
50574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50575     return 0;
50576   }
50577   {
50578     try {
50579       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
50580     } catch (std::out_of_range& e) {
50581       {
50582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50583       };
50584     } catch (std::exception& e) {
50585       {
50586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50587       };
50588     } catch (Dali::DaliException e) {
50589       {
50590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50591       };
50592     } catch (...) {
50593       {
50594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50595       };
50596     }
50597   }
50598
50599   jresult = (void *)result;
50600   return jresult;
50601 }
50602
50603
50604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
50605   void * jresult ;
50606   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50607   Dali::Rect< float > *arg2 = 0 ;
50608   Dali::Rect< float > *result = 0 ;
50609
50610   arg1 = (Dali::Rect< float > *)jarg1;
50611   arg2 = (Dali::Rect< float > *)jarg2;
50612   if (!arg2) {
50613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50614     return 0;
50615   }
50616   {
50617     try {
50618       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
50619     } catch (std::out_of_range& e) {
50620       {
50621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50622       };
50623     } catch (std::exception& e) {
50624       {
50625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50626       };
50627     } catch (Dali::DaliException e) {
50628       {
50629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50630       };
50631     } catch (...) {
50632       {
50633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50634       };
50635     }
50636   }
50637
50638   jresult = (void *)result;
50639   return jresult;
50640 }
50641
50642
50643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
50644   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50645   float arg2 ;
50646   float arg3 ;
50647   float arg4 ;
50648   float arg5 ;
50649
50650   arg1 = (Dali::Rect< float > *)jarg1;
50651   arg2 = (float)jarg2;
50652   arg3 = (float)jarg3;
50653   arg4 = (float)jarg5;
50654   arg5 = (float)jarg4;
50655   {
50656     try {
50657       (arg1)->Set(arg2,arg3,arg4,arg5);
50658     } catch (std::out_of_range& e) {
50659       {
50660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50661       };
50662     } catch (std::exception& e) {
50663       {
50664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50665       };
50666     } catch (Dali::DaliException e) {
50667       {
50668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50669       };
50670     } catch (...) {
50671       {
50672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50673       };
50674     }
50675   }
50676
50677 }
50678
50679
50680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
50681   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50682   float arg2 ;
50683
50684   arg1 = (Dali::Rect< float > *)jarg1;
50685   arg2 = (float)jarg2;
50686   if (arg1) (arg1)->left = arg2;
50687 }
50688
50689
50690 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
50691   float jresult ;
50692   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50693   float result;
50694
50695   arg1 = (Dali::Rect< float > *)jarg1;
50696   result = (float) ((arg1)->left);
50697   jresult = result;
50698   return jresult;
50699 }
50700
50701
50702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
50703   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50704   float arg2 ;
50705
50706   arg1 = (Dali::Rect< float > *)jarg1;
50707   arg2 = (float)jarg2;
50708   if (arg1) (arg1)->left = arg2;
50709 }
50710
50711
50712 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
50713   float jresult ;
50714   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50715   float result;
50716
50717   arg1 = (Dali::Rect< float > *)jarg1;
50718   result = (float) ((arg1)->left);
50719   jresult = result;
50720   return jresult;
50721 }
50722
50723
50724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
50725   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50726   float arg2 ;
50727
50728   arg1 = (Dali::Rect< float > *)jarg1;
50729   arg2 = (float)jarg2;
50730   if (arg1) (arg1)->right = arg2;
50731 }
50732
50733
50734 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
50735   float jresult ;
50736   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50737   float result;
50738
50739   arg1 = (Dali::Rect< float > *)jarg1;
50740   result = (float) ((arg1)->right);
50741   jresult = result;
50742   return jresult;
50743 }
50744
50745
50746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
50747   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50748   float arg2 ;
50749
50750   arg1 = (Dali::Rect< float > *)jarg1;
50751   arg2 = (float)jarg2;
50752   if (arg1) (arg1)->right = arg2;
50753 }
50754
50755
50756 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
50757   float jresult ;
50758   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50759   float result;
50760
50761   arg1 = (Dali::Rect< float > *)jarg1;
50762   result = (float) ((arg1)->right);
50763   jresult = result;
50764   return jresult;
50765 }
50766
50767
50768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
50769   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50770   float arg2 ;
50771
50772   arg1 = (Dali::Rect< float > *)jarg1;
50773   arg2 = (float)jarg2;
50774   if (arg1) (arg1)->bottom = arg2;
50775 }
50776
50777
50778 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
50779   float jresult ;
50780   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50781   float result;
50782
50783   arg1 = (Dali::Rect< float > *)jarg1;
50784   result = (float) ((arg1)->bottom);
50785   jresult = result;
50786   return jresult;
50787 }
50788
50789
50790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
50791   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50792   float arg2 ;
50793
50794   arg1 = (Dali::Rect< float > *)jarg1;
50795   arg2 = (float)jarg2;
50796   if (arg1) (arg1)->top = arg2;
50797 }
50798
50799
50800 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
50801   float jresult ;
50802   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50803   float result;
50804
50805   arg1 = (Dali::Rect< float > *)jarg1;
50806   result = (float) ((arg1)->top);
50807   jresult = result;
50808   return jresult;
50809 }
50810
50811
50812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
50813   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50814
50815   arg1 = (Dali::Rect< float > *)jarg1;
50816   {
50817     try {
50818       delete arg1;
50819     } catch (std::out_of_range& e) {
50820       {
50821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50822       };
50823     } catch (std::exception& e) {
50824       {
50825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50826       };
50827     } catch (Dali::DaliException e) {
50828       {
50829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50830       };
50831     } catch (...) {
50832       {
50833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50834       };
50835     }
50836   }
50837
50838 }
50839
50840
50841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
50842   int jresult ;
50843   int result;
50844
50845   result = (int)Dali::Vector< int >::BaseType;
50846   jresult = (int)result;
50847   return jresult;
50848 }
50849
50850
50851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
50852   void * jresult ;
50853   Dali::Vector< int > *result = 0 ;
50854
50855   {
50856     try {
50857       result = (Dali::Vector< int > *)new Dali::Vector< int >();
50858     } catch (std::out_of_range& e) {
50859       {
50860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50861       };
50862     } catch (std::exception& e) {
50863       {
50864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50865       };
50866     } catch (Dali::DaliException e) {
50867       {
50868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50869       };
50870     } catch (...) {
50871       {
50872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50873       };
50874     }
50875   }
50876
50877   jresult = (void *)result;
50878   return jresult;
50879 }
50880
50881
50882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
50883   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
50884
50885   arg1 = (Dali::Vector< int > *)jarg1;
50886   {
50887     try {
50888       delete arg1;
50889     } catch (std::out_of_range& e) {
50890       {
50891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50892       };
50893     } catch (std::exception& e) {
50894       {
50895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50896       };
50897     } catch (Dali::DaliException e) {
50898       {
50899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50900       };
50901     } catch (...) {
50902       {
50903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50904       };
50905     }
50906   }
50907
50908 }
50909
50910
50911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
50912   void * jresult ;
50913   Dali::Vector< int > *arg1 = 0 ;
50914   Dali::Vector< int > *result = 0 ;
50915
50916   arg1 = (Dali::Vector< int > *)jarg1;
50917   if (!arg1) {
50918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
50919     return 0;
50920   }
50921   {
50922     try {
50923       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
50924     } catch (std::out_of_range& e) {
50925       {
50926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50927       };
50928     } catch (std::exception& e) {
50929       {
50930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50931       };
50932     } catch (Dali::DaliException e) {
50933       {
50934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50935       };
50936     } catch (...) {
50937       {
50938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50939       };
50940     }
50941   }
50942
50943   jresult = (void *)result;
50944   return jresult;
50945 }
50946
50947
50948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
50949   void * jresult ;
50950   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
50951   Dali::Vector< int > *arg2 = 0 ;
50952   Dali::Vector< int > *result = 0 ;
50953
50954   arg1 = (Dali::Vector< int > *)jarg1;
50955   arg2 = (Dali::Vector< int > *)jarg2;
50956   if (!arg2) {
50957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
50958     return 0;
50959   }
50960   {
50961     try {
50962       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
50963     } catch (std::out_of_range& e) {
50964       {
50965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50966       };
50967     } catch (std::exception& e) {
50968       {
50969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50970       };
50971     } catch (Dali::DaliException e) {
50972       {
50973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50974       };
50975     } catch (...) {
50976       {
50977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50978       };
50979     }
50980   }
50981
50982   jresult = (void *)result;
50983   return jresult;
50984 }
50985
50986
50987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
50988   void * jresult ;
50989   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
50990   Dali::Vector< int >::Iterator result;
50991
50992   arg1 = (Dali::Vector< int > *)jarg1;
50993   {
50994     try {
50995       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
50996     } catch (std::out_of_range& e) {
50997       {
50998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50999       };
51000     } catch (std::exception& e) {
51001       {
51002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51003       };
51004     } catch (Dali::DaliException e) {
51005       {
51006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51007       };
51008     } catch (...) {
51009       {
51010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51011       };
51012     }
51013   }
51014
51015   jresult = (void *)result;
51016   return jresult;
51017 }
51018
51019
51020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
51021   void * jresult ;
51022   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51023   Dali::Vector< int >::Iterator result;
51024
51025   arg1 = (Dali::Vector< int > *)jarg1;
51026   {
51027     try {
51028       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
51029     } catch (std::out_of_range& e) {
51030       {
51031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51032       };
51033     } catch (std::exception& e) {
51034       {
51035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51036       };
51037     } catch (Dali::DaliException e) {
51038       {
51039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51040       };
51041     } catch (...) {
51042       {
51043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51044       };
51045     }
51046   }
51047
51048   jresult = (void *)result;
51049   return jresult;
51050 }
51051
51052
51053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51054   void * jresult ;
51055   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51056   Dali::Vector< int >::SizeType arg2 ;
51057   Dali::Vector< int >::ItemType *result = 0 ;
51058
51059   arg1 = (Dali::Vector< int > *)jarg1;
51060   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51061   {
51062     try {
51063       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
51064     } catch (std::out_of_range& e) {
51065       {
51066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51067       };
51068     } catch (std::exception& e) {
51069       {
51070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51071       };
51072     } catch (Dali::DaliException e) {
51073       {
51074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51075       };
51076     } catch (...) {
51077       {
51078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51079       };
51080     }
51081   }
51082
51083   jresult = (void *)result;
51084   return jresult;
51085 }
51086
51087
51088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
51089   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51090   Dali::Vector< int >::ItemType *arg2 = 0 ;
51091   Dali::Vector< int >::ItemType temp2 ;
51092
51093   arg1 = (Dali::Vector< int > *)jarg1;
51094   temp2 = (Dali::Vector< int >::ItemType)jarg2;
51095   arg2 = &temp2;
51096   {
51097     try {
51098       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
51099     } catch (std::out_of_range& e) {
51100       {
51101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51102       };
51103     } catch (std::exception& e) {
51104       {
51105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51106       };
51107     } catch (Dali::DaliException e) {
51108       {
51109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51110       };
51111     } catch (...) {
51112       {
51113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51114       };
51115     }
51116   }
51117
51118 }
51119
51120
51121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
51122   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51123   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51124   Dali::Vector< int >::ItemType *arg3 = 0 ;
51125   Dali::Vector< int >::ItemType temp3 ;
51126
51127   arg1 = (Dali::Vector< int > *)jarg1;
51128   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51129   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51130   arg3 = &temp3;
51131   {
51132     try {
51133       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51134     } catch (std::out_of_range& e) {
51135       {
51136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51137       };
51138     } catch (std::exception& e) {
51139       {
51140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51141       };
51142     } catch (Dali::DaliException e) {
51143       {
51144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51145       };
51146     } catch (...) {
51147       {
51148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51149       };
51150     }
51151   }
51152
51153 }
51154
51155
51156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51157   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51158   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51159   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51160   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
51161
51162   arg1 = (Dali::Vector< int > *)jarg1;
51163   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51164   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51165   arg4 = (Dali::Vector< int >::Iterator)jarg4;
51166   {
51167     try {
51168       (arg1)->Insert(arg2,arg3,arg4);
51169     } catch (std::out_of_range& e) {
51170       {
51171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51172       };
51173     } catch (std::exception& e) {
51174       {
51175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51176       };
51177     } catch (Dali::DaliException e) {
51178       {
51179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51180       };
51181     } catch (...) {
51182       {
51183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51184       };
51185     }
51186   }
51187
51188 }
51189
51190
51191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
51192   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51193   Dali::Vector< int >::SizeType arg2 ;
51194
51195   arg1 = (Dali::Vector< int > *)jarg1;
51196   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51197   {
51198     try {
51199       (arg1)->Reserve(arg2);
51200     } catch (std::out_of_range& e) {
51201       {
51202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51203       };
51204     } catch (std::exception& e) {
51205       {
51206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51207       };
51208     } catch (Dali::DaliException e) {
51209       {
51210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51211       };
51212     } catch (...) {
51213       {
51214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51215       };
51216     }
51217   }
51218
51219 }
51220
51221
51222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
51223   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51224   Dali::Vector< int >::SizeType arg2 ;
51225
51226   arg1 = (Dali::Vector< int > *)jarg1;
51227   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51228   {
51229     try {
51230       (arg1)->Resize(arg2);
51231     } catch (std::out_of_range& e) {
51232       {
51233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51234       };
51235     } catch (std::exception& e) {
51236       {
51237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51238       };
51239     } catch (Dali::DaliException e) {
51240       {
51241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51242       };
51243     } catch (...) {
51244       {
51245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51246       };
51247     }
51248   }
51249
51250 }
51251
51252
51253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
51254   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51255   Dali::Vector< int >::SizeType arg2 ;
51256   Dali::Vector< int >::ItemType *arg3 = 0 ;
51257   Dali::Vector< int >::ItemType temp3 ;
51258
51259   arg1 = (Dali::Vector< int > *)jarg1;
51260   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51261   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51262   arg3 = &temp3;
51263   {
51264     try {
51265       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51266     } catch (std::out_of_range& e) {
51267       {
51268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51269       };
51270     } catch (std::exception& e) {
51271       {
51272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51273       };
51274     } catch (Dali::DaliException e) {
51275       {
51276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51277       };
51278     } catch (...) {
51279       {
51280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51281       };
51282     }
51283   }
51284
51285 }
51286
51287
51288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
51289   void * jresult ;
51290   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51291   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51292   Dali::Vector< int >::Iterator result;
51293
51294   arg1 = (Dali::Vector< int > *)jarg1;
51295   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51296   {
51297     try {
51298       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
51299     } catch (std::out_of_range& e) {
51300       {
51301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51302       };
51303     } catch (std::exception& e) {
51304       {
51305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51306       };
51307     } catch (Dali::DaliException e) {
51308       {
51309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51310       };
51311     } catch (...) {
51312       {
51313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51314       };
51315     }
51316   }
51317
51318   jresult = (void *)result;
51319   return jresult;
51320 }
51321
51322
51323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
51324   void * jresult ;
51325   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51326   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51327   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51328   Dali::Vector< int >::Iterator result;
51329
51330   arg1 = (Dali::Vector< int > *)jarg1;
51331   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51332   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51333   {
51334     try {
51335       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
51336     } catch (std::out_of_range& e) {
51337       {
51338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51339       };
51340     } catch (std::exception& e) {
51341       {
51342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51343       };
51344     } catch (Dali::DaliException e) {
51345       {
51346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51347       };
51348     } catch (...) {
51349       {
51350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51351       };
51352     }
51353   }
51354
51355   jresult = (void *)result;
51356   return jresult;
51357 }
51358
51359
51360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
51361   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51362   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51363
51364   arg1 = (Dali::Vector< int > *)jarg1;
51365   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51366   {
51367     try {
51368       (arg1)->Remove(arg2);
51369     } catch (std::out_of_range& e) {
51370       {
51371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51372       };
51373     } catch (std::exception& e) {
51374       {
51375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51376       };
51377     } catch (Dali::DaliException e) {
51378       {
51379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51380       };
51381     } catch (...) {
51382       {
51383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51384       };
51385     }
51386   }
51387
51388 }
51389
51390
51391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
51392   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51393   Dali::Vector< int > *arg2 = 0 ;
51394
51395   arg1 = (Dali::Vector< int > *)jarg1;
51396   arg2 = (Dali::Vector< int > *)jarg2;
51397   if (!arg2) {
51398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
51399     return ;
51400   }
51401   {
51402     try {
51403       (arg1)->Swap(*arg2);
51404     } catch (std::out_of_range& e) {
51405       {
51406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51407       };
51408     } catch (std::exception& e) {
51409       {
51410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51411       };
51412     } catch (Dali::DaliException e) {
51413       {
51414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51415       };
51416     } catch (...) {
51417       {
51418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51419       };
51420     }
51421   }
51422
51423 }
51424
51425
51426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
51427   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51428
51429   arg1 = (Dali::Vector< int > *)jarg1;
51430   {
51431     try {
51432       (arg1)->Clear();
51433     } catch (std::out_of_range& e) {
51434       {
51435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51436       };
51437     } catch (std::exception& e) {
51438       {
51439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51440       };
51441     } catch (Dali::DaliException e) {
51442       {
51443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51444       };
51445     } catch (...) {
51446       {
51447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51448       };
51449     }
51450   }
51451
51452 }
51453
51454
51455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
51456   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51457
51458   arg1 = (Dali::Vector< int > *)jarg1;
51459   {
51460     try {
51461       (arg1)->Release();
51462     } catch (std::out_of_range& e) {
51463       {
51464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51465       };
51466     } catch (std::exception& e) {
51467       {
51468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51469       };
51470     } catch (Dali::DaliException e) {
51471       {
51472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51473       };
51474     } catch (...) {
51475       {
51476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51477       };
51478     }
51479   }
51480
51481 }
51482
51483
51484 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
51485   int jresult ;
51486   int result;
51487
51488   result = (int)Dali::Vector< float >::BaseType;
51489   jresult = (int)result;
51490   return jresult;
51491 }
51492
51493
51494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
51495   void * jresult ;
51496   Dali::Vector< float > *result = 0 ;
51497
51498   {
51499     try {
51500       result = (Dali::Vector< float > *)new Dali::Vector< float >();
51501     } catch (std::out_of_range& e) {
51502       {
51503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51504       };
51505     } catch (std::exception& e) {
51506       {
51507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51508       };
51509     } catch (Dali::DaliException e) {
51510       {
51511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51512       };
51513     } catch (...) {
51514       {
51515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51516       };
51517     }
51518   }
51519
51520   jresult = (void *)result;
51521   return jresult;
51522 }
51523
51524
51525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
51526   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51527
51528   arg1 = (Dali::Vector< float > *)jarg1;
51529   {
51530     try {
51531       delete arg1;
51532     } catch (std::out_of_range& e) {
51533       {
51534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51535       };
51536     } catch (std::exception& e) {
51537       {
51538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51539       };
51540     } catch (Dali::DaliException e) {
51541       {
51542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51543       };
51544     } catch (...) {
51545       {
51546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51547       };
51548     }
51549   }
51550
51551 }
51552
51553
51554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
51555   void * jresult ;
51556   Dali::Vector< float > *arg1 = 0 ;
51557   Dali::Vector< float > *result = 0 ;
51558
51559   arg1 = (Dali::Vector< float > *)jarg1;
51560   if (!arg1) {
51561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51562     return 0;
51563   }
51564   {
51565     try {
51566       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
51567     } catch (std::out_of_range& e) {
51568       {
51569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51570       };
51571     } catch (std::exception& e) {
51572       {
51573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51574       };
51575     } catch (Dali::DaliException e) {
51576       {
51577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51578       };
51579     } catch (...) {
51580       {
51581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51582       };
51583     }
51584   }
51585
51586   jresult = (void *)result;
51587   return jresult;
51588 }
51589
51590
51591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
51592   void * jresult ;
51593   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51594   Dali::Vector< float > *arg2 = 0 ;
51595   Dali::Vector< float > *result = 0 ;
51596
51597   arg1 = (Dali::Vector< float > *)jarg1;
51598   arg2 = (Dali::Vector< float > *)jarg2;
51599   if (!arg2) {
51600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51601     return 0;
51602   }
51603   {
51604     try {
51605       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
51606     } catch (std::out_of_range& e) {
51607       {
51608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51609       };
51610     } catch (std::exception& e) {
51611       {
51612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51613       };
51614     } catch (Dali::DaliException e) {
51615       {
51616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51617       };
51618     } catch (...) {
51619       {
51620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51621       };
51622     }
51623   }
51624
51625   jresult = (void *)result;
51626   return jresult;
51627 }
51628
51629
51630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
51631   void * jresult ;
51632   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51633   Dali::Vector< float >::Iterator result;
51634
51635   arg1 = (Dali::Vector< float > *)jarg1;
51636   {
51637     try {
51638       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
51639     } catch (std::out_of_range& e) {
51640       {
51641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51642       };
51643     } catch (std::exception& e) {
51644       {
51645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51646       };
51647     } catch (Dali::DaliException e) {
51648       {
51649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51650       };
51651     } catch (...) {
51652       {
51653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51654       };
51655     }
51656   }
51657
51658   jresult = (void *)result;
51659   return jresult;
51660 }
51661
51662
51663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
51664   void * jresult ;
51665   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51666   Dali::Vector< float >::Iterator result;
51667
51668   arg1 = (Dali::Vector< float > *)jarg1;
51669   {
51670     try {
51671       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
51672     } catch (std::out_of_range& e) {
51673       {
51674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51675       };
51676     } catch (std::exception& e) {
51677       {
51678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51679       };
51680     } catch (Dali::DaliException e) {
51681       {
51682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51683       };
51684     } catch (...) {
51685       {
51686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51687       };
51688     }
51689   }
51690
51691   jresult = (void *)result;
51692   return jresult;
51693 }
51694
51695
51696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51697   void * jresult ;
51698   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51699   Dali::Vector< float >::SizeType arg2 ;
51700   Dali::Vector< float >::ItemType *result = 0 ;
51701
51702   arg1 = (Dali::Vector< float > *)jarg1;
51703   arg2 = (Dali::Vector< float >::SizeType)jarg2;
51704   {
51705     try {
51706       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
51707     } catch (std::out_of_range& e) {
51708       {
51709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51710       };
51711     } catch (std::exception& e) {
51712       {
51713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51714       };
51715     } catch (Dali::DaliException e) {
51716       {
51717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51718       };
51719     } catch (...) {
51720       {
51721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51722       };
51723     }
51724   }
51725
51726   jresult = (void *)result;
51727   return jresult;
51728 }
51729
51730
51731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
51732   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51733   Dali::Vector< float >::ItemType *arg2 = 0 ;
51734   Dali::Vector< float >::ItemType temp2 ;
51735
51736   arg1 = (Dali::Vector< float > *)jarg1;
51737   temp2 = (Dali::Vector< float >::ItemType)jarg2;
51738   arg2 = &temp2;
51739   {
51740     try {
51741       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
51742     } catch (std::out_of_range& e) {
51743       {
51744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51745       };
51746     } catch (std::exception& e) {
51747       {
51748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51749       };
51750     } catch (Dali::DaliException e) {
51751       {
51752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51753       };
51754     } catch (...) {
51755       {
51756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51757       };
51758     }
51759   }
51760
51761 }
51762
51763
51764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
51765   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51766   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
51767   Dali::Vector< float >::ItemType *arg3 = 0 ;
51768   Dali::Vector< float >::ItemType temp3 ;
51769
51770   arg1 = (Dali::Vector< float > *)jarg1;
51771   arg2 = (Dali::Vector< float >::Iterator)jarg2;
51772   temp3 = (Dali::Vector< float >::ItemType)jarg3;
51773   arg3 = &temp3;
51774   {
51775     try {
51776       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
51777     } catch (std::out_of_range& e) {
51778       {
51779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51780       };
51781     } catch (std::exception& e) {
51782       {
51783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51784       };
51785     } catch (Dali::DaliException e) {
51786       {
51787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51788       };
51789     } catch (...) {
51790       {
51791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51792       };
51793     }
51794   }
51795
51796 }
51797
51798
51799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51800   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51801   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
51802   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
51803   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
51804
51805   arg1 = (Dali::Vector< float > *)jarg1;
51806   arg2 = (Dali::Vector< float >::Iterator)jarg2;
51807   arg3 = (Dali::Vector< float >::Iterator)jarg3;
51808   arg4 = (Dali::Vector< float >::Iterator)jarg4;
51809   {
51810     try {
51811       (arg1)->Insert(arg2,arg3,arg4);
51812     } catch (std::out_of_range& e) {
51813       {
51814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51815       };
51816     } catch (std::exception& e) {
51817       {
51818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51819       };
51820     } catch (Dali::DaliException e) {
51821       {
51822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51823       };
51824     } catch (...) {
51825       {
51826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51827       };
51828     }
51829   }
51830
51831 }
51832
51833
51834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
51835   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51836   Dali::Vector< float >::SizeType arg2 ;
51837
51838   arg1 = (Dali::Vector< float > *)jarg1;
51839   arg2 = (Dali::Vector< float >::SizeType)jarg2;
51840   {
51841     try {
51842       (arg1)->Reserve(arg2);
51843     } catch (std::out_of_range& e) {
51844       {
51845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51846       };
51847     } catch (std::exception& e) {
51848       {
51849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51850       };
51851     } catch (Dali::DaliException e) {
51852       {
51853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51854       };
51855     } catch (...) {
51856       {
51857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51858       };
51859     }
51860   }
51861
51862 }
51863
51864 //// ========================= end of part 2 =============================
51865
51866 //// ========================== start part 3 ===============================
51867
51868
51869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
51870   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51871   Dali::Vector< float >::SizeType arg2 ;
51872
51873   arg1 = (Dali::Vector< float > *)jarg1;
51874   arg2 = (Dali::Vector< float >::SizeType)jarg2;
51875   {
51876     try {
51877       (arg1)->Resize(arg2);
51878     } catch (std::out_of_range& e) {
51879       {
51880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51881       };
51882     } catch (std::exception& e) {
51883       {
51884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51885       };
51886     } catch (Dali::DaliException e) {
51887       {
51888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51889       };
51890     } catch (...) {
51891       {
51892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51893       };
51894     }
51895   }
51896
51897 }
51898
51899
51900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
51901   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51902   Dali::Vector< float >::SizeType arg2 ;
51903   Dali::Vector< float >::ItemType *arg3 = 0 ;
51904   Dali::Vector< float >::ItemType temp3 ;
51905
51906   arg1 = (Dali::Vector< float > *)jarg1;
51907   arg2 = (Dali::Vector< float >::SizeType)jarg2;
51908   temp3 = (Dali::Vector< float >::ItemType)jarg3;
51909   arg3 = &temp3;
51910   {
51911     try {
51912       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
51913     } catch (std::out_of_range& e) {
51914       {
51915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51916       };
51917     } catch (std::exception& e) {
51918       {
51919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51920       };
51921     } catch (Dali::DaliException e) {
51922       {
51923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51924       };
51925     } catch (...) {
51926       {
51927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51928       };
51929     }
51930   }
51931
51932 }
51933
51934
51935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
51936   void * jresult ;
51937   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51938   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
51939   Dali::Vector< float >::Iterator result;
51940
51941   arg1 = (Dali::Vector< float > *)jarg1;
51942   arg2 = (Dali::Vector< float >::Iterator)jarg2;
51943   {
51944     try {
51945       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
51946     } catch (std::out_of_range& e) {
51947       {
51948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51949       };
51950     } catch (std::exception& e) {
51951       {
51952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51953       };
51954     } catch (Dali::DaliException e) {
51955       {
51956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51957       };
51958     } catch (...) {
51959       {
51960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51961       };
51962     }
51963   }
51964
51965   jresult = (void *)result;
51966   return jresult;
51967 }
51968
51969
51970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
51971   void * jresult ;
51972   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51973   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
51974   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
51975   Dali::Vector< float >::Iterator result;
51976
51977   arg1 = (Dali::Vector< float > *)jarg1;
51978   arg2 = (Dali::Vector< float >::Iterator)jarg2;
51979   arg3 = (Dali::Vector< float >::Iterator)jarg3;
51980   {
51981     try {
51982       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
51983     } catch (std::out_of_range& e) {
51984       {
51985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51986       };
51987     } catch (std::exception& e) {
51988       {
51989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51990       };
51991     } catch (Dali::DaliException e) {
51992       {
51993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51994       };
51995     } catch (...) {
51996       {
51997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51998       };
51999     }
52000   }
52001
52002   jresult = (void *)result;
52003   return jresult;
52004 }
52005
52006
52007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
52008   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52009   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52010
52011   arg1 = (Dali::Vector< float > *)jarg1;
52012   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52013   {
52014     try {
52015       (arg1)->Remove(arg2);
52016     } catch (std::out_of_range& e) {
52017       {
52018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52019       };
52020     } catch (std::exception& e) {
52021       {
52022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52023       };
52024     } catch (Dali::DaliException e) {
52025       {
52026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52027       };
52028     } catch (...) {
52029       {
52030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52031       };
52032     }
52033   }
52034
52035 }
52036
52037
52038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
52039   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52040   Dali::Vector< float > *arg2 = 0 ;
52041
52042   arg1 = (Dali::Vector< float > *)jarg1;
52043   arg2 = (Dali::Vector< float > *)jarg2;
52044   if (!arg2) {
52045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
52046     return ;
52047   }
52048   {
52049     try {
52050       (arg1)->Swap(*arg2);
52051     } catch (std::out_of_range& e) {
52052       {
52053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52054       };
52055     } catch (std::exception& e) {
52056       {
52057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52058       };
52059     } catch (Dali::DaliException e) {
52060       {
52061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52062       };
52063     } catch (...) {
52064       {
52065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52066       };
52067     }
52068   }
52069
52070 }
52071
52072
52073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
52074   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52075
52076   arg1 = (Dali::Vector< float > *)jarg1;
52077   {
52078     try {
52079       (arg1)->Clear();
52080     } catch (std::out_of_range& e) {
52081       {
52082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52083       };
52084     } catch (std::exception& e) {
52085       {
52086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52087       };
52088     } catch (Dali::DaliException e) {
52089       {
52090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52091       };
52092     } catch (...) {
52093       {
52094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52095       };
52096     }
52097   }
52098
52099 }
52100
52101
52102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
52103   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52104
52105   arg1 = (Dali::Vector< float > *)jarg1;
52106   {
52107     try {
52108       (arg1)->Release();
52109     } catch (std::out_of_range& e) {
52110       {
52111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52112       };
52113     } catch (std::exception& e) {
52114       {
52115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52116       };
52117     } catch (Dali::DaliException e) {
52118       {
52119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52120       };
52121     } catch (...) {
52122       {
52123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52124       };
52125     }
52126   }
52127
52128 }
52129
52130
52131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
52132   int jresult ;
52133   int result;
52134
52135   result = (int)Dali::Vector< unsigned char >::BaseType;
52136   jresult = (int)result;
52137   return jresult;
52138 }
52139
52140
52141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
52142   void * jresult ;
52143   Dali::Vector< unsigned char > *result = 0 ;
52144
52145   {
52146     try {
52147       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
52148     } catch (std::out_of_range& e) {
52149       {
52150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52151       };
52152     } catch (std::exception& e) {
52153       {
52154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52155       };
52156     } catch (Dali::DaliException e) {
52157       {
52158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52159       };
52160     } catch (...) {
52161       {
52162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52163       };
52164     }
52165   }
52166
52167   jresult = (void *)result;
52168   return jresult;
52169 }
52170
52171
52172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
52173   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52174
52175   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52176   {
52177     try {
52178       delete arg1;
52179     } catch (std::out_of_range& e) {
52180       {
52181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52182       };
52183     } catch (std::exception& e) {
52184       {
52185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52186       };
52187     } catch (Dali::DaliException e) {
52188       {
52189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52190       };
52191     } catch (...) {
52192       {
52193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52194       };
52195     }
52196   }
52197
52198 }
52199
52200
52201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
52202   void * jresult ;
52203   Dali::Vector< unsigned char > *arg1 = 0 ;
52204   Dali::Vector< unsigned char > *result = 0 ;
52205
52206   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52207   if (!arg1) {
52208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52209     return 0;
52210   }
52211   {
52212     try {
52213       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
52214     } catch (std::out_of_range& e) {
52215       {
52216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52217       };
52218     } catch (std::exception& e) {
52219       {
52220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52221       };
52222     } catch (Dali::DaliException e) {
52223       {
52224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52225       };
52226     } catch (...) {
52227       {
52228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52229       };
52230     }
52231   }
52232
52233   jresult = (void *)result;
52234   return jresult;
52235 }
52236
52237
52238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
52239   void * jresult ;
52240   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52241   Dali::Vector< unsigned char > *arg2 = 0 ;
52242   Dali::Vector< unsigned char > *result = 0 ;
52243
52244   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52245   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52246   if (!arg2) {
52247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52248     return 0;
52249   }
52250   {
52251     try {
52252       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
52253     } catch (std::out_of_range& e) {
52254       {
52255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52256       };
52257     } catch (std::exception& e) {
52258       {
52259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52260       };
52261     } catch (Dali::DaliException e) {
52262       {
52263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52264       };
52265     } catch (...) {
52266       {
52267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52268       };
52269     }
52270   }
52271
52272   jresult = (void *)result;
52273   return jresult;
52274 }
52275
52276
52277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
52278   void * jresult ;
52279   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52280   Dali::Vector< unsigned char >::Iterator result;
52281
52282   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52283   {
52284     try {
52285       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
52286     } catch (std::out_of_range& e) {
52287       {
52288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52289       };
52290     } catch (std::exception& e) {
52291       {
52292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52293       };
52294     } catch (Dali::DaliException e) {
52295       {
52296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52297       };
52298     } catch (...) {
52299       {
52300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52301       };
52302     }
52303   }
52304
52305   jresult = (void *)result;
52306   return jresult;
52307 }
52308
52309
52310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
52311   void * jresult ;
52312   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52313   Dali::Vector< unsigned char >::Iterator result;
52314
52315   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52316   {
52317     try {
52318       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
52319     } catch (std::out_of_range& e) {
52320       {
52321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52322       };
52323     } catch (std::exception& e) {
52324       {
52325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52326       };
52327     } catch (Dali::DaliException e) {
52328       {
52329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52330       };
52331     } catch (...) {
52332       {
52333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52334       };
52335     }
52336   }
52337
52338   jresult = (void *)result;
52339   return jresult;
52340 }
52341
52342
52343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
52344   void * jresult ;
52345   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52346   Dali::Vector< unsigned char >::SizeType arg2 ;
52347   Dali::Vector< unsigned char >::ItemType *result = 0 ;
52348
52349   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52350   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52351   {
52352     try {
52353       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
52354     } catch (std::out_of_range& e) {
52355       {
52356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52357       };
52358     } catch (std::exception& e) {
52359       {
52360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52361       };
52362     } catch (Dali::DaliException e) {
52363       {
52364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52365       };
52366     } catch (...) {
52367       {
52368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52369       };
52370     }
52371   }
52372
52373   jresult = (void *)result;
52374   return jresult;
52375 }
52376
52377
52378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
52379   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52380   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
52381   Dali::Vector< unsigned char >::ItemType temp2 ;
52382
52383   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52384   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
52385   arg2 = &temp2;
52386   {
52387     try {
52388       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
52389     } catch (std::out_of_range& e) {
52390       {
52391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52392       };
52393     } catch (std::exception& e) {
52394       {
52395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52396       };
52397     } catch (Dali::DaliException e) {
52398       {
52399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52400       };
52401     } catch (...) {
52402       {
52403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52404       };
52405     }
52406   }
52407
52408 }
52409
52410
52411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
52412   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52413   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52414   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52415   Dali::Vector< unsigned char >::ItemType temp3 ;
52416
52417   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52418   arg2 = jarg2;
52419   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52420   arg3 = &temp3;
52421   {
52422     try {
52423       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52424     } catch (std::out_of_range& e) {
52425       {
52426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52427       };
52428     } catch (std::exception& e) {
52429       {
52430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52431       };
52432     } catch (Dali::DaliException e) {
52433       {
52434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52435       };
52436     } catch (...) {
52437       {
52438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52439       };
52440     }
52441   }
52442
52443
52444
52445 }
52446
52447
52448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
52449   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52450   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52451   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52452   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52453
52454   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52455   arg2 = jarg2;
52456   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52457   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
52458   {
52459     try {
52460       (arg1)->Insert(arg2,arg3,arg4);
52461     } catch (std::out_of_range& e) {
52462       {
52463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52464       };
52465     } catch (std::exception& e) {
52466       {
52467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52468       };
52469     } catch (Dali::DaliException e) {
52470       {
52471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52472       };
52473     } catch (...) {
52474       {
52475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52476       };
52477     }
52478   }
52479
52480
52481
52482 }
52483
52484
52485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
52486   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52487   Dali::Vector< unsigned char >::SizeType arg2 ;
52488
52489   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52490   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52491   {
52492     try {
52493       (arg1)->Reserve(arg2);
52494     } catch (std::out_of_range& e) {
52495       {
52496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52497       };
52498     } catch (std::exception& e) {
52499       {
52500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52501       };
52502     } catch (Dali::DaliException e) {
52503       {
52504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52505       };
52506     } catch (...) {
52507       {
52508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52509       };
52510     }
52511   }
52512
52513 }
52514
52515
52516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52517   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52518   Dali::Vector< unsigned char >::SizeType arg2 ;
52519
52520   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52521   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52522   {
52523     try {
52524       (arg1)->Resize(arg2);
52525     } catch (std::out_of_range& e) {
52526       {
52527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52528       };
52529     } catch (std::exception& e) {
52530       {
52531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52532       };
52533     } catch (Dali::DaliException e) {
52534       {
52535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52536       };
52537     } catch (...) {
52538       {
52539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52540       };
52541     }
52542   }
52543
52544 }
52545
52546
52547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
52548   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52549   Dali::Vector< unsigned char >::SizeType arg2 ;
52550   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52551   Dali::Vector< unsigned char >::ItemType temp3 ;
52552
52553   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52554   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52555   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52556   arg3 = &temp3;
52557   {
52558     try {
52559       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52560     } catch (std::out_of_range& e) {
52561       {
52562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52563       };
52564     } catch (std::exception& e) {
52565       {
52566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52567       };
52568     } catch (Dali::DaliException e) {
52569       {
52570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52571       };
52572     } catch (...) {
52573       {
52574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52575       };
52576     }
52577   }
52578
52579 }
52580
52581
52582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
52583   void * jresult ;
52584   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52585   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52586   Dali::Vector< unsigned char >::Iterator result;
52587
52588   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52589   arg2 = jarg2;
52590   {
52591     try {
52592       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
52593     } catch (std::out_of_range& e) {
52594       {
52595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52596       };
52597     } catch (std::exception& e) {
52598       {
52599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52600       };
52601     } catch (Dali::DaliException e) {
52602       {
52603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52604       };
52605     } catch (...) {
52606       {
52607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52608       };
52609     }
52610   }
52611
52612   jresult = (void *)result;
52613
52614
52615   return jresult;
52616 }
52617
52618
52619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
52620   void * jresult ;
52621   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52622   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52623   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52624   Dali::Vector< unsigned char >::Iterator result;
52625
52626   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52627   arg2 = jarg2;
52628   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52629   {
52630     try {
52631       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
52632     } catch (std::out_of_range& e) {
52633       {
52634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52635       };
52636     } catch (std::exception& e) {
52637       {
52638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52639       };
52640     } catch (Dali::DaliException e) {
52641       {
52642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52643       };
52644     } catch (...) {
52645       {
52646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52647       };
52648     }
52649   }
52650
52651   jresult = (void *)result;
52652
52653
52654   return jresult;
52655 }
52656
52657
52658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
52659   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52660   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52661
52662   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52663   arg2 = jarg2;
52664   {
52665     try {
52666       (arg1)->Remove(arg2);
52667     } catch (std::out_of_range& e) {
52668       {
52669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52670       };
52671     } catch (std::exception& e) {
52672       {
52673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52674       };
52675     } catch (Dali::DaliException e) {
52676       {
52677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52678       };
52679     } catch (...) {
52680       {
52681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52682       };
52683     }
52684   }
52685
52686
52687
52688 }
52689
52690
52691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
52692   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52693   Dali::Vector< unsigned char > *arg2 = 0 ;
52694
52695   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52696   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52697   if (!arg2) {
52698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
52699     return ;
52700   }
52701   {
52702     try {
52703       (arg1)->Swap(*arg2);
52704     } catch (std::out_of_range& e) {
52705       {
52706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52707       };
52708     } catch (std::exception& e) {
52709       {
52710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52711       };
52712     } catch (Dali::DaliException e) {
52713       {
52714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52715       };
52716     } catch (...) {
52717       {
52718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52719       };
52720     }
52721   }
52722
52723 }
52724
52725
52726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
52727   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52728
52729   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52730   {
52731     try {
52732       (arg1)->Clear();
52733     } catch (std::out_of_range& e) {
52734       {
52735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52736       };
52737     } catch (std::exception& e) {
52738       {
52739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52740       };
52741     } catch (Dali::DaliException e) {
52742       {
52743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52744       };
52745     } catch (...) {
52746       {
52747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52748       };
52749     }
52750   }
52751
52752 }
52753
52754
52755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
52756   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52757
52758   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52759   {
52760     try {
52761       (arg1)->Release();
52762     } catch (std::out_of_range& e) {
52763       {
52764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52765       };
52766     } catch (std::exception& e) {
52767       {
52768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52769       };
52770     } catch (Dali::DaliException e) {
52771       {
52772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52773       };
52774     } catch (...) {
52775       {
52776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52777       };
52778     }
52779   }
52780
52781 }
52782
52783
52784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
52785   int jresult ;
52786   int result;
52787
52788   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
52789   jresult = (int)result;
52790   return jresult;
52791 }
52792
52793
52794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
52795   void * jresult ;
52796   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
52797
52798   {
52799     try {
52800       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
52801     } catch (std::out_of_range& e) {
52802       {
52803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52804       };
52805     } catch (std::exception& e) {
52806       {
52807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52808       };
52809     } catch (Dali::DaliException e) {
52810       {
52811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52812       };
52813     } catch (...) {
52814       {
52815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52816       };
52817     }
52818   }
52819
52820   jresult = (void *)result;
52821   return jresult;
52822 }
52823
52824
52825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
52826   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
52827
52828   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
52829   {
52830     try {
52831       delete arg1;
52832     } catch (std::out_of_range& e) {
52833       {
52834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52835       };
52836     } catch (std::exception& e) {
52837       {
52838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52839       };
52840     } catch (Dali::DaliException e) {
52841       {
52842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52843       };
52844     } catch (...) {
52845       {
52846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52847       };
52848     }
52849   }
52850
52851 }
52852
52853
52854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
52855   void * jresult ;
52856   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
52857   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
52858
52859   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
52860   if (!arg1) {
52861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
52862     return 0;
52863   }
52864   {
52865     try {
52866       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
52867     } catch (std::out_of_range& e) {
52868       {
52869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52870       };
52871     } catch (std::exception& e) {
52872       {
52873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52874       };
52875     } catch (Dali::DaliException e) {
52876       {
52877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52878       };
52879     } catch (...) {
52880       {
52881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52882       };
52883     }
52884   }
52885
52886   jresult = (void *)result;
52887   return jresult;
52888 }
52889
52890
52891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
52892   void * jresult ;
52893   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
52894   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
52895   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
52896
52897   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
52898   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
52899   if (!arg2) {
52900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
52901     return 0;
52902   }
52903   {
52904     try {
52905       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
52906     } catch (std::out_of_range& e) {
52907       {
52908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52909       };
52910     } catch (std::exception& e) {
52911       {
52912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52913       };
52914     } catch (Dali::DaliException e) {
52915       {
52916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52917       };
52918     } catch (...) {
52919       {
52920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52921       };
52922     }
52923   }
52924
52925   jresult = (void *)result;
52926   return jresult;
52927 }
52928
52929
52930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
52931   void * jresult ;
52932   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
52933   Dali::Vector< Dali::Uint16Pair >::Iterator result;
52934
52935   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
52936   {
52937     try {
52938       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
52939     } catch (std::out_of_range& e) {
52940       {
52941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52942       };
52943     } catch (std::exception& e) {
52944       {
52945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52946       };
52947     } catch (Dali::DaliException e) {
52948       {
52949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52950       };
52951     } catch (...) {
52952       {
52953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52954       };
52955     }
52956   }
52957
52958   jresult = (void *)result;
52959   return jresult;
52960 }
52961
52962
52963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
52964   void * jresult ;
52965   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
52966   Dali::Vector< Dali::Uint16Pair >::Iterator result;
52967
52968   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
52969   {
52970     try {
52971       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
52972     } catch (std::out_of_range& e) {
52973       {
52974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52975       };
52976     } catch (std::exception& e) {
52977       {
52978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52979       };
52980     } catch (Dali::DaliException e) {
52981       {
52982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52983       };
52984     } catch (...) {
52985       {
52986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52987       };
52988     }
52989   }
52990
52991   jresult = (void *)result;
52992   return jresult;
52993 }
52994
52995
52996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
52997   void * jresult ;
52998   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
52999   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53000   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
53001
53002   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53003   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53004   {
53005     try {
53006       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
53007     } catch (std::out_of_range& e) {
53008       {
53009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53010       };
53011     } catch (std::exception& e) {
53012       {
53013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53014       };
53015     } catch (Dali::DaliException e) {
53016       {
53017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53018       };
53019     } catch (...) {
53020       {
53021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53022       };
53023     }
53024   }
53025
53026   jresult = (void *)result;
53027   return jresult;
53028 }
53029
53030
53031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
53032   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53033   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
53034
53035   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53036   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
53037   if (!arg2) {
53038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53039     return ;
53040   }
53041   {
53042     try {
53043       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
53044     } catch (std::out_of_range& e) {
53045       {
53046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53047       };
53048     } catch (std::exception& e) {
53049       {
53050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53051       };
53052     } catch (Dali::DaliException e) {
53053       {
53054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53055       };
53056     } catch (...) {
53057       {
53058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53059       };
53060     }
53061   }
53062
53063 }
53064
53065
53066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
53067   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53068   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53069   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53070
53071   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53072   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53073   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53074   if (!arg3) {
53075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53076     return ;
53077   }
53078   {
53079     try {
53080       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53081     } catch (std::out_of_range& e) {
53082       {
53083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53084       };
53085     } catch (std::exception& e) {
53086       {
53087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53088       };
53089     } catch (Dali::DaliException e) {
53090       {
53091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53092       };
53093     } catch (...) {
53094       {
53095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53096       };
53097     }
53098   }
53099
53100 }
53101
53102
53103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
53104   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53105   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53106   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53107   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53108
53109   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53110   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53111   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53112   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
53113   {
53114     try {
53115       (arg1)->Insert(arg2,arg3,arg4);
53116     } catch (std::out_of_range& e) {
53117       {
53118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53119       };
53120     } catch (std::exception& e) {
53121       {
53122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53123       };
53124     } catch (Dali::DaliException e) {
53125       {
53126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53127       };
53128     } catch (...) {
53129       {
53130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53131       };
53132     }
53133   }
53134
53135 }
53136
53137
53138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
53139   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53140   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53141
53142   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53143   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53144   {
53145     try {
53146       (arg1)->Reserve(arg2);
53147     } catch (std::out_of_range& e) {
53148       {
53149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53150       };
53151     } catch (std::exception& e) {
53152       {
53153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53154       };
53155     } catch (Dali::DaliException e) {
53156       {
53157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53158       };
53159     } catch (...) {
53160       {
53161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53162       };
53163     }
53164   }
53165
53166 }
53167
53168
53169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
53170   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53171   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53172
53173   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53174   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53175   {
53176     try {
53177       (arg1)->Resize(arg2);
53178     } catch (std::out_of_range& e) {
53179       {
53180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53181       };
53182     } catch (std::exception& e) {
53183       {
53184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53185       };
53186     } catch (Dali::DaliException e) {
53187       {
53188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53189       };
53190     } catch (...) {
53191       {
53192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53193       };
53194     }
53195   }
53196
53197 }
53198
53199
53200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
53201   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53202   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53203   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53204
53205   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53206   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53207   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53208   if (!arg3) {
53209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53210     return ;
53211   }
53212   {
53213     try {
53214       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53215     } catch (std::out_of_range& e) {
53216       {
53217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53218       };
53219     } catch (std::exception& e) {
53220       {
53221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53222       };
53223     } catch (Dali::DaliException e) {
53224       {
53225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53226       };
53227     } catch (...) {
53228       {
53229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53230       };
53231     }
53232   }
53233
53234 }
53235
53236
53237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
53238   void * jresult ;
53239   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53240   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53241   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53242
53243   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53244   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53245   {
53246     try {
53247       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
53248     } catch (std::out_of_range& e) {
53249       {
53250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53251       };
53252     } catch (std::exception& e) {
53253       {
53254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53255       };
53256     } catch (Dali::DaliException e) {
53257       {
53258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53259       };
53260     } catch (...) {
53261       {
53262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53263       };
53264     }
53265   }
53266
53267   jresult = (void *)result;
53268   return jresult;
53269 }
53270
53271
53272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
53273   void * jresult ;
53274   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53275   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53276   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53277   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53278
53279   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53280   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53281   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53282   {
53283     try {
53284       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
53285     } catch (std::out_of_range& e) {
53286       {
53287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53288       };
53289     } catch (std::exception& e) {
53290       {
53291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53292       };
53293     } catch (Dali::DaliException e) {
53294       {
53295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53296       };
53297     } catch (...) {
53298       {
53299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53300       };
53301     }
53302   }
53303
53304   jresult = (void *)result;
53305   return jresult;
53306 }
53307
53308
53309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
53310   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53311   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53312
53313   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53314   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53315   {
53316     try {
53317       (arg1)->Remove(arg2);
53318     } catch (std::out_of_range& e) {
53319       {
53320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53321       };
53322     } catch (std::exception& e) {
53323       {
53324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53325       };
53326     } catch (Dali::DaliException e) {
53327       {
53328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53329       };
53330     } catch (...) {
53331       {
53332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53333       };
53334     }
53335   }
53336
53337 }
53338
53339
53340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
53341   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53342   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53343
53344   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53345   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53346   if (!arg2) {
53347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
53348     return ;
53349   }
53350   {
53351     try {
53352       (arg1)->Swap(*arg2);
53353     } catch (std::out_of_range& e) {
53354       {
53355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53356       };
53357     } catch (std::exception& e) {
53358       {
53359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53360       };
53361     } catch (Dali::DaliException e) {
53362       {
53363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53364       };
53365     } catch (...) {
53366       {
53367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53368       };
53369     }
53370   }
53371
53372 }
53373
53374
53375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
53376   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53377
53378   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53379   {
53380     try {
53381       (arg1)->Clear();
53382     } catch (std::out_of_range& e) {
53383       {
53384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53385       };
53386     } catch (std::exception& e) {
53387       {
53388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53389       };
53390     } catch (Dali::DaliException e) {
53391       {
53392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53393       };
53394     } catch (...) {
53395       {
53396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53397       };
53398     }
53399   }
53400
53401 }
53402
53403
53404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
53405   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53406
53407   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53408   {
53409     try {
53410       (arg1)->Release();
53411     } catch (std::out_of_range& e) {
53412       {
53413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53414       };
53415     } catch (std::exception& e) {
53416       {
53417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53418       };
53419     } catch (Dali::DaliException e) {
53420       {
53421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53422       };
53423     } catch (...) {
53424       {
53425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53426       };
53427     }
53428   }
53429
53430 }
53431
53432
53433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
53434   void * jresult ;
53435   Dali::Signal< void () > *result = 0 ;
53436
53437   {
53438     try {
53439       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
53440     } catch (std::out_of_range& e) {
53441       {
53442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53443       };
53444     } catch (std::exception& e) {
53445       {
53446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53447       };
53448     } catch (Dali::DaliException e) {
53449       {
53450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53451       };
53452     } catch (...) {
53453       {
53454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53455       };
53456     }
53457   }
53458
53459   jresult = (void *)result;
53460   return jresult;
53461 }
53462
53463
53464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
53465   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53466
53467   arg1 = (Dali::Signal< void () > *)jarg1;
53468   {
53469     try {
53470       delete arg1;
53471     } catch (std::out_of_range& e) {
53472       {
53473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53474       };
53475     } catch (std::exception& e) {
53476       {
53477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53478       };
53479     } catch (Dali::DaliException e) {
53480       {
53481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53482       };
53483     } catch (...) {
53484       {
53485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53486       };
53487     }
53488   }
53489
53490 }
53491
53492
53493 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
53494   unsigned int jresult ;
53495   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53496   bool result;
53497
53498   arg1 = (Dali::Signal< void () > *)jarg1;
53499   {
53500     try {
53501       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
53502     } catch (std::out_of_range& e) {
53503       {
53504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53505       };
53506     } catch (std::exception& e) {
53507       {
53508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53509       };
53510     } catch (Dali::DaliException e) {
53511       {
53512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53513       };
53514     } catch (...) {
53515       {
53516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53517       };
53518     }
53519   }
53520
53521   jresult = result;
53522   return jresult;
53523 }
53524
53525
53526 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
53527   unsigned long jresult ;
53528   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53529   std::size_t result;
53530
53531   arg1 = (Dali::Signal< void () > *)jarg1;
53532   {
53533     try {
53534       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
53535     } catch (std::out_of_range& e) {
53536       {
53537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53538       };
53539     } catch (std::exception& e) {
53540       {
53541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53542       };
53543     } catch (Dali::DaliException e) {
53544       {
53545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53546       };
53547     } catch (...) {
53548       {
53549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53550       };
53551     }
53552   }
53553
53554   jresult = (unsigned long)result;
53555   return jresult;
53556 }
53557
53558
53559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
53560   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53561   void (*arg2)() = (void (*)()) 0 ;
53562
53563   arg1 = (Dali::Signal< void () > *)jarg1;
53564   arg2 = (void (*)())jarg2;
53565   {
53566     try {
53567       (arg1)->Connect(arg2);
53568     } catch (std::out_of_range& e) {
53569       {
53570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53571       };
53572     } catch (std::exception& e) {
53573       {
53574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53575       };
53576     } catch (Dali::DaliException e) {
53577       {
53578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53579       };
53580     } catch (...) {
53581       {
53582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53583       };
53584     }
53585   }
53586
53587 }
53588
53589
53590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
53591   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53592   void (*arg2)() = (void (*)()) 0 ;
53593
53594   arg1 = (Dali::Signal< void () > *)jarg1;
53595   arg2 = (void (*)())jarg2;
53596   {
53597     try {
53598       (arg1)->Disconnect(arg2);
53599     } catch (std::out_of_range& e) {
53600       {
53601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53602       };
53603     } catch (std::exception& e) {
53604       {
53605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53606       };
53607     } catch (Dali::DaliException e) {
53608       {
53609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53610       };
53611     } catch (...) {
53612       {
53613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53614       };
53615     }
53616   }
53617
53618 }
53619
53620
53621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
53622   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53623   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
53624   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
53625
53626   arg1 = (Dali::Signal< void () > *)jarg1;
53627   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
53628   arg3 = (Dali::FunctorDelegate *)jarg3;
53629   {
53630     try {
53631       (arg1)->Connect(arg2,arg3);
53632     } catch (std::out_of_range& e) {
53633       {
53634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53635       };
53636     } catch (std::exception& e) {
53637       {
53638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53639       };
53640     } catch (Dali::DaliException e) {
53641       {
53642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53643       };
53644     } catch (...) {
53645       {
53646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53647       };
53648     }
53649   }
53650
53651 }
53652
53653
53654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
53655   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53656
53657   arg1 = (Dali::Signal< void () > *)jarg1;
53658   {
53659     try {
53660       (arg1)->Emit();
53661     } catch (std::out_of_range& e) {
53662       {
53663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53664       };
53665     } catch (std::exception& e) {
53666       {
53667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53668       };
53669     } catch (Dali::DaliException e) {
53670       {
53671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53672       };
53673     } catch (...) {
53674       {
53675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53676       };
53677     }
53678   }
53679
53680 }
53681
53682
53683 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
53684   unsigned int jresult ;
53685   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53686   bool result;
53687
53688   arg1 = (Dali::Signal< void (float) > *)jarg1;
53689   {
53690     try {
53691       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
53692     } catch (std::out_of_range& e) {
53693       {
53694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53695       };
53696     } catch (std::exception& e) {
53697       {
53698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53699       };
53700     } catch (Dali::DaliException e) {
53701       {
53702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53703       };
53704     } catch (...) {
53705       {
53706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53707       };
53708     }
53709   }
53710
53711   jresult = result;
53712   return jresult;
53713 }
53714
53715
53716 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
53717   unsigned long jresult ;
53718   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53719   std::size_t result;
53720
53721   arg1 = (Dali::Signal< void (float) > *)jarg1;
53722   {
53723     try {
53724       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
53725     } catch (std::out_of_range& e) {
53726       {
53727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53728       };
53729     } catch (std::exception& e) {
53730       {
53731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53732       };
53733     } catch (Dali::DaliException e) {
53734       {
53735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53736       };
53737     } catch (...) {
53738       {
53739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53740       };
53741     }
53742   }
53743
53744   jresult = (unsigned long)result;
53745   return jresult;
53746 }
53747
53748
53749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
53750   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53751   void (*arg2)(float) = (void (*)(float)) 0 ;
53752
53753   arg1 = (Dali::Signal< void (float) > *)jarg1;
53754   arg2 = (void (*)(float))jarg2;
53755   {
53756     try {
53757       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
53758     } catch (std::out_of_range& e) {
53759       {
53760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53761       };
53762     } catch (std::exception& e) {
53763       {
53764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53765       };
53766     } catch (Dali::DaliException e) {
53767       {
53768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53769       };
53770     } catch (...) {
53771       {
53772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53773       };
53774     }
53775   }
53776
53777 }
53778
53779
53780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
53781   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53782   void (*arg2)(float) = (void (*)(float)) 0 ;
53783
53784   arg1 = (Dali::Signal< void (float) > *)jarg1;
53785   arg2 = (void (*)(float))jarg2;
53786   {
53787     try {
53788       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
53789     } catch (std::out_of_range& e) {
53790       {
53791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53792       };
53793     } catch (std::exception& e) {
53794       {
53795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53796       };
53797     } catch (Dali::DaliException e) {
53798       {
53799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53800       };
53801     } catch (...) {
53802       {
53803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53804       };
53805     }
53806   }
53807
53808 }
53809
53810
53811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
53812   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53813   float arg2 ;
53814
53815   arg1 = (Dali::Signal< void (float) > *)jarg1;
53816   arg2 = (float)jarg2;
53817   {
53818     try {
53819       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
53820     } catch (std::out_of_range& e) {
53821       {
53822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53823       };
53824     } catch (std::exception& e) {
53825       {
53826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53827       };
53828     } catch (Dali::DaliException e) {
53829       {
53830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53831       };
53832     } catch (...) {
53833       {
53834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53835       };
53836     }
53837   }
53838
53839 }
53840
53841
53842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
53843   void * jresult ;
53844   Dali::Signal< void (float) > *result = 0 ;
53845
53846   {
53847     try {
53848       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
53849     } catch (std::out_of_range& e) {
53850       {
53851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53852       };
53853     } catch (std::exception& e) {
53854       {
53855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53856       };
53857     } catch (Dali::DaliException e) {
53858       {
53859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53860       };
53861     } catch (...) {
53862       {
53863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53864       };
53865     }
53866   }
53867
53868   jresult = (void *)result;
53869   return jresult;
53870 }
53871
53872
53873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
53874   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53875
53876   arg1 = (Dali::Signal< void (float) > *)jarg1;
53877   {
53878     try {
53879       delete arg1;
53880     } catch (std::out_of_range& e) {
53881       {
53882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53883       };
53884     } catch (std::exception& e) {
53885       {
53886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53887       };
53888     } catch (Dali::DaliException e) {
53889       {
53890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53891       };
53892     } catch (...) {
53893       {
53894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53895       };
53896     }
53897   }
53898
53899 }
53900
53901
53902 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
53903   unsigned int jresult ;
53904   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
53905   bool result;
53906
53907   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
53908   {
53909     try {
53910       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
53911     } catch (std::out_of_range& e) {
53912       {
53913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53914       };
53915     } catch (std::exception& e) {
53916       {
53917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53918       };
53919     } catch (Dali::DaliException e) {
53920       {
53921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53922       };
53923     } catch (...) {
53924       {
53925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53926       };
53927     }
53928   }
53929
53930   jresult = result;
53931   return jresult;
53932 }
53933
53934
53935 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
53936   unsigned long jresult ;
53937   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
53938   std::size_t result;
53939
53940   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
53941   {
53942     try {
53943       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
53944     } catch (std::out_of_range& e) {
53945       {
53946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53947       };
53948     } catch (std::exception& e) {
53949       {
53950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53951       };
53952     } catch (Dali::DaliException e) {
53953       {
53954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53955       };
53956     } catch (...) {
53957       {
53958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53959       };
53960     }
53961   }
53962
53963   jresult = (unsigned long)result;
53964   return jresult;
53965 }
53966
53967
53968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
53969   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
53970   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
53971
53972   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
53973   arg2 = (void (*)(Dali::BaseHandle))jarg2;
53974   {
53975     try {
53976       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
53977     } catch (std::out_of_range& e) {
53978       {
53979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53980       };
53981     } catch (std::exception& e) {
53982       {
53983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53984       };
53985     } catch (Dali::DaliException e) {
53986       {
53987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53988       };
53989     } catch (...) {
53990       {
53991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53992       };
53993     }
53994   }
53995
53996 }
53997
53998
53999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
54000   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54001   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54002
54003   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54004   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54005   {
54006     try {
54007       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
54008     } catch (std::out_of_range& e) {
54009       {
54010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54011       };
54012     } catch (std::exception& e) {
54013       {
54014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54015       };
54016     } catch (Dali::DaliException e) {
54017       {
54018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54019       };
54020     } catch (...) {
54021       {
54022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54023       };
54024     }
54025   }
54026
54027 }
54028
54029
54030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
54031   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54032   Dali::BaseHandle arg2 ;
54033   Dali::BaseHandle *argp2 ;
54034
54035   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54036   argp2 = (Dali::BaseHandle *)jarg2;
54037   if (!argp2) {
54038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54039     return ;
54040   }
54041   arg2 = *argp2;
54042   {
54043     try {
54044       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
54045     } catch (std::out_of_range& e) {
54046       {
54047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54048       };
54049     } catch (std::exception& e) {
54050       {
54051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54052       };
54053     } catch (Dali::DaliException e) {
54054       {
54055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54056       };
54057     } catch (...) {
54058       {
54059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54060       };
54061     }
54062   }
54063
54064 }
54065
54066
54067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
54068   void * jresult ;
54069   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
54070
54071   {
54072     try {
54073       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
54074     } catch (std::out_of_range& e) {
54075       {
54076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54077       };
54078     } catch (std::exception& e) {
54079       {
54080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54081       };
54082     } catch (Dali::DaliException e) {
54083       {
54084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54085       };
54086     } catch (...) {
54087       {
54088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54089       };
54090     }
54091   }
54092
54093   jresult = (void *)result;
54094   return jresult;
54095 }
54096
54097
54098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
54099   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54100
54101   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54102   {
54103     try {
54104       delete arg1;
54105     } catch (std::out_of_range& e) {
54106       {
54107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54108       };
54109     } catch (std::exception& e) {
54110       {
54111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54112       };
54113     } catch (Dali::DaliException e) {
54114       {
54115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54116       };
54117     } catch (...) {
54118       {
54119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54120       };
54121     }
54122   }
54123
54124 }
54125
54126
54127 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
54128   unsigned int jresult ;
54129   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54130   bool result;
54131
54132   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54133   {
54134     try {
54135       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54136     } catch (std::out_of_range& e) {
54137       {
54138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54139       };
54140     } catch (std::exception& e) {
54141       {
54142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54143       };
54144     } catch (Dali::DaliException e) {
54145       {
54146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54147       };
54148     } catch (...) {
54149       {
54150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54151       };
54152     }
54153   }
54154
54155   jresult = result;
54156   return jresult;
54157 }
54158
54159
54160 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
54161   unsigned long jresult ;
54162   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54163   std::size_t result;
54164
54165   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54166   {
54167     try {
54168       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54169     } catch (std::out_of_range& e) {
54170       {
54171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54172       };
54173     } catch (std::exception& e) {
54174       {
54175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54176       };
54177     } catch (Dali::DaliException e) {
54178       {
54179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54180       };
54181     } catch (...) {
54182       {
54183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54184       };
54185     }
54186   }
54187
54188   jresult = (unsigned long)result;
54189   return jresult;
54190 }
54191
54192
54193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
54194   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54195   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54196
54197   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54198   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54199   {
54200     try {
54201       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
54202     } catch (std::out_of_range& e) {
54203       {
54204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54205       };
54206     } catch (std::exception& e) {
54207       {
54208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54209       };
54210     } catch (Dali::DaliException e) {
54211       {
54212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54213       };
54214     } catch (...) {
54215       {
54216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54217       };
54218     }
54219   }
54220
54221 }
54222
54223
54224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
54225   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54226   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54227
54228   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54229   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54230   {
54231     try {
54232       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
54233     } catch (std::out_of_range& e) {
54234       {
54235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54236       };
54237     } catch (std::exception& e) {
54238       {
54239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54240       };
54241     } catch (Dali::DaliException e) {
54242       {
54243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54244       };
54245     } catch (...) {
54246       {
54247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54248       };
54249     }
54250   }
54251
54252 }
54253
54254
54255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
54256   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54257   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
54258
54259   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54260   arg2 = (Dali::RefObject *)jarg2;
54261   {
54262     try {
54263       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
54264     } catch (std::out_of_range& e) {
54265       {
54266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54267       };
54268     } catch (std::exception& e) {
54269       {
54270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54271       };
54272     } catch (Dali::DaliException e) {
54273       {
54274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54275       };
54276     } catch (...) {
54277       {
54278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54279       };
54280     }
54281   }
54282
54283 }
54284
54285
54286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
54287   void * jresult ;
54288   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
54289
54290   {
54291     try {
54292       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
54293     } catch (std::out_of_range& e) {
54294       {
54295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54296       };
54297     } catch (std::exception& e) {
54298       {
54299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54300       };
54301     } catch (Dali::DaliException e) {
54302       {
54303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54304       };
54305     } catch (...) {
54306       {
54307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54308       };
54309     }
54310   }
54311
54312   jresult = (void *)result;
54313   return jresult;
54314 }
54315
54316
54317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
54318   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54319
54320   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54321   {
54322     try {
54323       delete arg1;
54324     } catch (std::out_of_range& e) {
54325       {
54326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54327       };
54328     } catch (std::exception& e) {
54329       {
54330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54331       };
54332     } catch (Dali::DaliException e) {
54333       {
54334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54335       };
54336     } catch (...) {
54337       {
54338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54339       };
54340     }
54341   }
54342
54343 }
54344
54345
54346 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
54347   unsigned int jresult ;
54348   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54349   bool result;
54350
54351   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54352   {
54353     try {
54354       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54355     } catch (std::out_of_range& e) {
54356       {
54357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54358       };
54359     } catch (std::exception& e) {
54360       {
54361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54362       };
54363     } catch (Dali::DaliException e) {
54364       {
54365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54366       };
54367     } catch (...) {
54368       {
54369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54370       };
54371     }
54372   }
54373
54374   jresult = result;
54375   return jresult;
54376 }
54377
54378
54379 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
54380   unsigned long jresult ;
54381   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54382   std::size_t result;
54383
54384   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54385   {
54386     try {
54387       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54388     } catch (std::out_of_range& e) {
54389       {
54390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54391       };
54392     } catch (std::exception& e) {
54393       {
54394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54395       };
54396     } catch (Dali::DaliException e) {
54397       {
54398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54399       };
54400     } catch (...) {
54401       {
54402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54403       };
54404     }
54405   }
54406
54407   jresult = (unsigned long)result;
54408   return jresult;
54409 }
54410
54411
54412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
54413   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54414   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54415
54416   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54417   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54418   {
54419     try {
54420       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
54421     } catch (std::out_of_range& e) {
54422       {
54423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54424       };
54425     } catch (std::exception& e) {
54426       {
54427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54428       };
54429     } catch (Dali::DaliException e) {
54430       {
54431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54432       };
54433     } catch (...) {
54434       {
54435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54436       };
54437     }
54438   }
54439
54440 }
54441
54442
54443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
54444   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54445   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54446
54447   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54448   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54449   {
54450     try {
54451       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
54452     } catch (std::out_of_range& e) {
54453       {
54454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54455       };
54456     } catch (std::exception& e) {
54457       {
54458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54459       };
54460     } catch (Dali::DaliException e) {
54461       {
54462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54463       };
54464     } catch (...) {
54465       {
54466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54467       };
54468     }
54469   }
54470
54471 }
54472
54473
54474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
54475   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54476   Dali::PropertyNotification *arg2 = 0 ;
54477
54478   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54479   arg2 = (Dali::PropertyNotification *)jarg2;
54480   if (!arg2) {
54481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
54482     return ;
54483   }
54484   {
54485     try {
54486       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
54487     } catch (std::out_of_range& e) {
54488       {
54489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54490       };
54491     } catch (std::exception& e) {
54492       {
54493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54494       };
54495     } catch (Dali::DaliException e) {
54496       {
54497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54498       };
54499     } catch (...) {
54500       {
54501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54502       };
54503     }
54504   }
54505
54506 }
54507
54508
54509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
54510   void * jresult ;
54511   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
54512
54513   {
54514     try {
54515       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
54516     } catch (std::out_of_range& e) {
54517       {
54518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54519       };
54520     } catch (std::exception& e) {
54521       {
54522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54523       };
54524     } catch (Dali::DaliException e) {
54525       {
54526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54527       };
54528     } catch (...) {
54529       {
54530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54531       };
54532     }
54533   }
54534
54535   jresult = (void *)result;
54536   return jresult;
54537 }
54538
54539
54540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
54541   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54542
54543   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54544   {
54545     try {
54546       delete arg1;
54547     } catch (std::out_of_range& e) {
54548       {
54549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54550       };
54551     } catch (std::exception& e) {
54552       {
54553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54554       };
54555     } catch (Dali::DaliException e) {
54556       {
54557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54558       };
54559     } catch (...) {
54560       {
54561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54562       };
54563     }
54564   }
54565
54566 }
54567
54568
54569 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
54570   unsigned int jresult ;
54571   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54572   bool result;
54573
54574   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54575   {
54576     try {
54577       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
54578     } catch (std::out_of_range& e) {
54579       {
54580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54581       };
54582     } catch (std::exception& e) {
54583       {
54584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54585       };
54586     } catch (Dali::DaliException e) {
54587       {
54588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54589       };
54590     } catch (...) {
54591       {
54592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54593       };
54594     }
54595   }
54596
54597   jresult = result;
54598   return jresult;
54599 }
54600
54601
54602 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
54603   unsigned long jresult ;
54604   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54605   std::size_t result;
54606
54607   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54608   {
54609     try {
54610       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
54611     } catch (std::out_of_range& e) {
54612       {
54613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54614       };
54615     } catch (std::exception& e) {
54616       {
54617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54618       };
54619     } catch (Dali::DaliException e) {
54620       {
54621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54622       };
54623     } catch (...) {
54624       {
54625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54626       };
54627     }
54628   }
54629
54630   jresult = (unsigned long)result;
54631   return jresult;
54632 }
54633
54634
54635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
54636   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54637   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54638
54639   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54640   arg2 = (void (*)(Dali::Image))jarg2;
54641   {
54642     try {
54643       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
54644     } catch (std::out_of_range& e) {
54645       {
54646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54647       };
54648     } catch (std::exception& e) {
54649       {
54650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54651       };
54652     } catch (Dali::DaliException e) {
54653       {
54654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54655       };
54656     } catch (...) {
54657       {
54658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54659       };
54660     }
54661   }
54662
54663 }
54664
54665
54666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
54667   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54668   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54669
54670   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54671   arg2 = (void (*)(Dali::Image))jarg2;
54672   {
54673     try {
54674       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
54675     } catch (std::out_of_range& e) {
54676       {
54677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54678       };
54679     } catch (std::exception& e) {
54680       {
54681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54682       };
54683     } catch (Dali::DaliException e) {
54684       {
54685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54686       };
54687     } catch (...) {
54688       {
54689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54690       };
54691     }
54692   }
54693
54694 }
54695
54696
54697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
54698   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54699   Dali::Image arg2 ;
54700   Dali::Image *argp2 ;
54701
54702   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54703   argp2 = (Dali::Image *)jarg2;
54704   if (!argp2) {
54705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
54706     return ;
54707   }
54708   arg2 = *argp2;
54709   {
54710     try {
54711       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
54712     } catch (std::out_of_range& e) {
54713       {
54714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54715       };
54716     } catch (std::exception& e) {
54717       {
54718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54719       };
54720     } catch (Dali::DaliException e) {
54721       {
54722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54723       };
54724     } catch (...) {
54725       {
54726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54727       };
54728     }
54729   }
54730
54731 }
54732
54733
54734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
54735   void * jresult ;
54736   Dali::Signal< void (Dali::Image) > *result = 0 ;
54737
54738   {
54739     try {
54740       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
54741     } catch (std::out_of_range& e) {
54742       {
54743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54744       };
54745     } catch (std::exception& e) {
54746       {
54747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54748       };
54749     } catch (Dali::DaliException e) {
54750       {
54751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54752       };
54753     } catch (...) {
54754       {
54755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54756       };
54757     }
54758   }
54759
54760   jresult = (void *)result;
54761   return jresult;
54762 }
54763
54764
54765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
54766   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54767
54768   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54769   {
54770     try {
54771       delete arg1;
54772     } catch (std::out_of_range& e) {
54773       {
54774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54775       };
54776     } catch (std::exception& e) {
54777       {
54778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54779       };
54780     } catch (Dali::DaliException e) {
54781       {
54782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54783       };
54784     } catch (...) {
54785       {
54786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54787       };
54788     }
54789   }
54790
54791 }
54792
54793
54794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
54795   void * jresult ;
54796   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
54797
54798   {
54799     try {
54800       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
54801     } catch (std::out_of_range& e) {
54802       {
54803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54804       };
54805     } catch (std::exception& e) {
54806       {
54807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54808       };
54809     } catch (Dali::DaliException e) {
54810       {
54811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54812       };
54813     } catch (...) {
54814       {
54815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54816       };
54817     }
54818   }
54819
54820   jresult = (void *)result;
54821   return jresult;
54822 }
54823
54824
54825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
54826   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
54827
54828   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
54829   {
54830     try {
54831       delete arg1;
54832     } catch (std::out_of_range& e) {
54833       {
54834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54835       };
54836     } catch (std::exception& e) {
54837       {
54838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54839       };
54840     } catch (Dali::DaliException e) {
54841       {
54842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54843       };
54844     } catch (...) {
54845       {
54846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54847       };
54848     }
54849   }
54850
54851 }
54852
54853
54854 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
54855   unsigned int jresult ;
54856   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
54857   bool result;
54858
54859   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
54860   {
54861     try {
54862       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);
54863     } catch (std::out_of_range& e) {
54864       {
54865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54866       };
54867     } catch (std::exception& e) {
54868       {
54869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54870       };
54871     } catch (Dali::DaliException e) {
54872       {
54873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54874       };
54875     } catch (...) {
54876       {
54877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54878       };
54879     }
54880   }
54881
54882   jresult = result;
54883   return jresult;
54884 }
54885
54886
54887 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
54888   unsigned long jresult ;
54889   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
54890   std::size_t result;
54891
54892   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
54893   {
54894     try {
54895       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);
54896     } catch (std::out_of_range& e) {
54897       {
54898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54899       };
54900     } catch (std::exception& e) {
54901       {
54902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54903       };
54904     } catch (Dali::DaliException e) {
54905       {
54906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54907       };
54908     } catch (...) {
54909       {
54910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54911       };
54912     }
54913   }
54914
54915   jresult = (unsigned long)result;
54916   return jresult;
54917 }
54918
54919
54920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
54921   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
54922   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
54923
54924   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
54925   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
54926   {
54927     try {
54928       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
54929     } catch (std::out_of_range& e) {
54930       {
54931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54932       };
54933     } catch (std::exception& e) {
54934       {
54935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54936       };
54937     } catch (Dali::DaliException e) {
54938       {
54939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54940       };
54941     } catch (...) {
54942       {
54943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54944       };
54945     }
54946   }
54947
54948 }
54949
54950
54951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
54952   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
54953   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
54954
54955   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
54956   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
54957   {
54958     try {
54959       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
54960     } catch (std::out_of_range& e) {
54961       {
54962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54963       };
54964     } catch (std::exception& e) {
54965       {
54966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54967       };
54968     } catch (Dali::DaliException e) {
54969       {
54970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54971       };
54972     } catch (...) {
54973       {
54974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54975       };
54976     }
54977   }
54978
54979 }
54980
54981
54982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
54983   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
54984   Dali::Actor arg2 ;
54985   Dali::LongPressGesture *arg3 = 0 ;
54986   Dali::Actor *argp2 ;
54987
54988   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
54989   argp2 = (Dali::Actor *)jarg2;
54990   if (!argp2) {
54991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54992     return ;
54993   }
54994   arg2 = *argp2;
54995   arg3 = (Dali::LongPressGesture *)jarg3;
54996   if (!arg3) {
54997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
54998     return ;
54999   }
55000   {
55001     try {
55002       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
55003     } catch (std::out_of_range& e) {
55004       {
55005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55006       };
55007     } catch (std::exception& e) {
55008       {
55009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55010       };
55011     } catch (Dali::DaliException e) {
55012       {
55013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55014       };
55015     } catch (...) {
55016       {
55017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55018       };
55019     }
55020   }
55021
55022 }
55023
55024
55025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
55026   void * jresult ;
55027   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
55028
55029   {
55030     try {
55031       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
55032     } catch (std::out_of_range& e) {
55033       {
55034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55035       };
55036     } catch (std::exception& e) {
55037       {
55038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55039       };
55040     } catch (Dali::DaliException e) {
55041       {
55042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55043       };
55044     } catch (...) {
55045       {
55046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55047       };
55048     }
55049   }
55050
55051   jresult = (void *)result;
55052   return jresult;
55053 }
55054
55055
55056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
55057   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55058
55059   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55060   {
55061     try {
55062       delete arg1;
55063     } catch (std::out_of_range& e) {
55064       {
55065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55066       };
55067     } catch (std::exception& e) {
55068       {
55069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55070       };
55071     } catch (Dali::DaliException e) {
55072       {
55073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55074       };
55075     } catch (...) {
55076       {
55077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55078       };
55079     }
55080   }
55081
55082 }
55083
55084
55085 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
55086   unsigned int jresult ;
55087   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55088   bool result;
55089
55090   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55091   {
55092     try {
55093       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);
55094     } catch (std::out_of_range& e) {
55095       {
55096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55097       };
55098     } catch (std::exception& e) {
55099       {
55100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55101       };
55102     } catch (Dali::DaliException e) {
55103       {
55104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55105       };
55106     } catch (...) {
55107       {
55108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55109       };
55110     }
55111   }
55112
55113   jresult = result;
55114   return jresult;
55115 }
55116
55117
55118 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
55119   unsigned long jresult ;
55120   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55121   std::size_t result;
55122
55123   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55124   {
55125     try {
55126       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);
55127     } catch (std::out_of_range& e) {
55128       {
55129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55130       };
55131     } catch (std::exception& e) {
55132       {
55133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55134       };
55135     } catch (Dali::DaliException e) {
55136       {
55137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55138       };
55139     } catch (...) {
55140       {
55141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55142       };
55143     }
55144   }
55145
55146   jresult = (unsigned long)result;
55147   return jresult;
55148 }
55149
55150
55151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
55152   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55153   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55154
55155   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55156   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55157   {
55158     try {
55159       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55160     } catch (std::out_of_range& e) {
55161       {
55162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55163       };
55164     } catch (std::exception& e) {
55165       {
55166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55167       };
55168     } catch (Dali::DaliException e) {
55169       {
55170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55171       };
55172     } catch (...) {
55173       {
55174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55175       };
55176     }
55177   }
55178
55179 }
55180
55181
55182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
55183   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55184   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55185
55186   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55187   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55188   {
55189     try {
55190       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55191     } catch (std::out_of_range& e) {
55192       {
55193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55194       };
55195     } catch (std::exception& e) {
55196       {
55197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55198       };
55199     } catch (Dali::DaliException e) {
55200       {
55201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55202       };
55203     } catch (...) {
55204       {
55205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55206       };
55207     }
55208   }
55209
55210 }
55211
55212
55213 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55214   unsigned int jresult ;
55215   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55216   Dali::Actor arg2 ;
55217   Dali::TouchData *arg3 = 0 ;
55218   Dali::Actor *argp2 ;
55219   bool result;
55220
55221   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55222   argp2 = (Dali::Actor *)jarg2;
55223   if (!argp2) {
55224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55225     return 0;
55226   }
55227   arg2 = *argp2;
55228   arg3 = (Dali::TouchData *)jarg3;
55229   if (!arg3) {
55230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
55231     return 0;
55232   }
55233   {
55234     try {
55235       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
55236     } catch (std::out_of_range& e) {
55237       {
55238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55239       };
55240     } catch (std::exception& e) {
55241       {
55242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55243       };
55244     } catch (Dali::DaliException e) {
55245       {
55246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55247       };
55248     } catch (...) {
55249       {
55250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55251       };
55252     }
55253   }
55254
55255   jresult = result;
55256   return jresult;
55257 }
55258
55259
55260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
55261   void * jresult ;
55262   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
55263
55264   {
55265     try {
55266       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
55267     } catch (std::out_of_range& e) {
55268       {
55269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55270       };
55271     } catch (std::exception& e) {
55272       {
55273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55274       };
55275     } catch (Dali::DaliException e) {
55276       {
55277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55278       };
55279     } catch (...) {
55280       {
55281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55282       };
55283     }
55284   }
55285
55286   jresult = (void *)result;
55287   return jresult;
55288 }
55289
55290
55291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
55292   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55293
55294   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55295   {
55296     try {
55297       delete arg1;
55298     } catch (std::out_of_range& e) {
55299       {
55300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55301       };
55302     } catch (std::exception& e) {
55303       {
55304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55305       };
55306     } catch (Dali::DaliException e) {
55307       {
55308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55309       };
55310     } catch (...) {
55311       {
55312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55313       };
55314     }
55315   }
55316
55317 }
55318
55319
55320 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
55321   unsigned int jresult ;
55322   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55323   bool result;
55324
55325   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55326   {
55327     try {
55328       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);
55329     } catch (std::out_of_range& e) {
55330       {
55331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55332       };
55333     } catch (std::exception& e) {
55334       {
55335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55336       };
55337     } catch (Dali::DaliException e) {
55338       {
55339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55340       };
55341     } catch (...) {
55342       {
55343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55344       };
55345     }
55346   }
55347
55348   jresult = result;
55349   return jresult;
55350 }
55351
55352
55353 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
55354   unsigned long jresult ;
55355   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55356   std::size_t result;
55357
55358   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55359   {
55360     try {
55361       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);
55362     } catch (std::out_of_range& e) {
55363       {
55364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55365       };
55366     } catch (std::exception& e) {
55367       {
55368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55369       };
55370     } catch (Dali::DaliException e) {
55371       {
55372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55373       };
55374     } catch (...) {
55375       {
55376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55377       };
55378     }
55379   }
55380
55381   jresult = (unsigned long)result;
55382   return jresult;
55383 }
55384
55385
55386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
55387   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55388   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55389
55390   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55391   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55392   {
55393     try {
55394       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55395     } catch (std::out_of_range& e) {
55396       {
55397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55398       };
55399     } catch (std::exception& e) {
55400       {
55401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55402       };
55403     } catch (Dali::DaliException e) {
55404       {
55405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55406       };
55407     } catch (...) {
55408       {
55409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55410       };
55411     }
55412   }
55413
55414 }
55415
55416
55417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
55418   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55419   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55420
55421   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55422   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55423   {
55424     try {
55425       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55426     } catch (std::out_of_range& e) {
55427       {
55428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55429       };
55430     } catch (std::exception& e) {
55431       {
55432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55433       };
55434     } catch (Dali::DaliException e) {
55435       {
55436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55437       };
55438     } catch (...) {
55439       {
55440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55441       };
55442     }
55443   }
55444
55445 }
55446
55447
55448 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55449   unsigned int jresult ;
55450   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55451   Dali::Actor arg2 ;
55452   Dali::HoverEvent *arg3 = 0 ;
55453   Dali::Actor *argp2 ;
55454   bool result;
55455
55456   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55457   argp2 = (Dali::Actor *)jarg2;
55458   if (!argp2) {
55459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55460     return 0;
55461   }
55462   arg2 = *argp2;
55463   arg3 = (Dali::HoverEvent *)jarg3;
55464   if (!arg3) {
55465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
55466     return 0;
55467   }
55468   {
55469     try {
55470       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
55471     } catch (std::out_of_range& e) {
55472       {
55473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55474       };
55475     } catch (std::exception& e) {
55476       {
55477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55478       };
55479     } catch (Dali::DaliException e) {
55480       {
55481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55482       };
55483     } catch (...) {
55484       {
55485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55486       };
55487     }
55488   }
55489
55490   jresult = result;
55491   return jresult;
55492 }
55493
55494
55495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
55496   void * jresult ;
55497   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
55498
55499   {
55500     try {
55501       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
55502     } catch (std::out_of_range& e) {
55503       {
55504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55505       };
55506     } catch (std::exception& e) {
55507       {
55508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55509       };
55510     } catch (Dali::DaliException e) {
55511       {
55512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55513       };
55514     } catch (...) {
55515       {
55516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55517       };
55518     }
55519   }
55520
55521   jresult = (void *)result;
55522   return jresult;
55523 }
55524
55525
55526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
55527   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55528
55529   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55530   {
55531     try {
55532       delete arg1;
55533     } catch (std::out_of_range& e) {
55534       {
55535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55536       };
55537     } catch (std::exception& e) {
55538       {
55539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55540       };
55541     } catch (Dali::DaliException e) {
55542       {
55543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55544       };
55545     } catch (...) {
55546       {
55547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55548       };
55549     }
55550   }
55551
55552 }
55553
55554
55555 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
55556   unsigned int jresult ;
55557   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55558   bool result;
55559
55560   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55561   {
55562     try {
55563       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);
55564     } catch (std::out_of_range& e) {
55565       {
55566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55567       };
55568     } catch (std::exception& e) {
55569       {
55570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55571       };
55572     } catch (Dali::DaliException e) {
55573       {
55574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55575       };
55576     } catch (...) {
55577       {
55578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55579       };
55580     }
55581   }
55582
55583   jresult = result;
55584   return jresult;
55585 }
55586
55587
55588 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
55589   unsigned long jresult ;
55590   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55591   std::size_t result;
55592
55593   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55594   {
55595     try {
55596       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);
55597     } catch (std::out_of_range& e) {
55598       {
55599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55600       };
55601     } catch (std::exception& e) {
55602       {
55603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55604       };
55605     } catch (Dali::DaliException e) {
55606       {
55607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55608       };
55609     } catch (...) {
55610       {
55611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55612       };
55613     }
55614   }
55615
55616   jresult = (unsigned long)result;
55617   return jresult;
55618 }
55619
55620
55621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
55622   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55623   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55624
55625   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55626   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55627   {
55628     try {
55629       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55630     } catch (std::out_of_range& e) {
55631       {
55632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55633       };
55634     } catch (std::exception& e) {
55635       {
55636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55637       };
55638     } catch (Dali::DaliException e) {
55639       {
55640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55641       };
55642     } catch (...) {
55643       {
55644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55645       };
55646     }
55647   }
55648
55649 }
55650
55651
55652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
55653   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55654   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55655
55656   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55657   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55658   {
55659     try {
55660       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55661     } catch (std::out_of_range& e) {
55662       {
55663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55664       };
55665     } catch (std::exception& e) {
55666       {
55667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55668       };
55669     } catch (Dali::DaliException e) {
55670       {
55671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55672       };
55673     } catch (...) {
55674       {
55675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55676       };
55677     }
55678   }
55679
55680 }
55681
55682
55683 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55684   unsigned int jresult ;
55685   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55686   Dali::Actor arg2 ;
55687   Dali::WheelEvent *arg3 = 0 ;
55688   Dali::Actor *argp2 ;
55689   bool result;
55690
55691   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55692   argp2 = (Dali::Actor *)jarg2;
55693   if (!argp2) {
55694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55695     return 0;
55696   }
55697   arg2 = *argp2;
55698   arg3 = (Dali::WheelEvent *)jarg3;
55699   if (!arg3) {
55700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
55701     return 0;
55702   }
55703   {
55704     try {
55705       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
55706     } catch (std::out_of_range& e) {
55707       {
55708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55709       };
55710     } catch (std::exception& e) {
55711       {
55712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55713       };
55714     } catch (Dali::DaliException e) {
55715       {
55716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55717       };
55718     } catch (...) {
55719       {
55720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55721       };
55722     }
55723   }
55724
55725   jresult = result;
55726   return jresult;
55727 }
55728
55729
55730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
55731   void * jresult ;
55732   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
55733
55734   {
55735     try {
55736       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
55737     } catch (std::out_of_range& e) {
55738       {
55739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55740       };
55741     } catch (std::exception& e) {
55742       {
55743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55744       };
55745     } catch (Dali::DaliException e) {
55746       {
55747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55748       };
55749     } catch (...) {
55750       {
55751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55752       };
55753     }
55754   }
55755
55756   jresult = (void *)result;
55757   return jresult;
55758 }
55759
55760
55761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
55762   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55763
55764   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55765   {
55766     try {
55767       delete arg1;
55768     } catch (std::out_of_range& e) {
55769       {
55770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55771       };
55772     } catch (std::exception& e) {
55773       {
55774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55775       };
55776     } catch (Dali::DaliException e) {
55777       {
55778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55779       };
55780     } catch (...) {
55781       {
55782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55783       };
55784     }
55785   }
55786
55787 }
55788
55789
55790 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
55791   unsigned int jresult ;
55792   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
55793   bool result;
55794
55795   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
55796   {
55797     try {
55798       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
55799     } catch (std::out_of_range& e) {
55800       {
55801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55802       };
55803     } catch (std::exception& e) {
55804       {
55805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55806       };
55807     } catch (Dali::DaliException e) {
55808       {
55809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55810       };
55811     } catch (...) {
55812       {
55813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55814       };
55815     }
55816   }
55817
55818   jresult = result;
55819   return jresult;
55820 }
55821
55822
55823 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
55824   unsigned long jresult ;
55825   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
55826   std::size_t result;
55827
55828   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
55829   {
55830     try {
55831       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
55832     } catch (std::out_of_range& e) {
55833       {
55834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55835       };
55836     } catch (std::exception& e) {
55837       {
55838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55839       };
55840     } catch (Dali::DaliException e) {
55841       {
55842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55843       };
55844     } catch (...) {
55845       {
55846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55847       };
55848     }
55849   }
55850
55851   jresult = (unsigned long)result;
55852   return jresult;
55853 }
55854
55855
55856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
55857   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
55858   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
55859
55860   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
55861   arg2 = (void (*)(Dali::Actor))jarg2;
55862   {
55863     try {
55864       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
55865     } catch (std::out_of_range& e) {
55866       {
55867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55868       };
55869     } catch (std::exception& e) {
55870       {
55871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55872       };
55873     } catch (Dali::DaliException e) {
55874       {
55875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55876       };
55877     } catch (...) {
55878       {
55879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55880       };
55881     }
55882   }
55883
55884 }
55885
55886
55887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
55888   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
55889   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
55890
55891   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
55892   arg2 = (void (*)(Dali::Actor))jarg2;
55893   {
55894     try {
55895       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
55896     } catch (std::out_of_range& e) {
55897       {
55898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55899       };
55900     } catch (std::exception& e) {
55901       {
55902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55903       };
55904     } catch (Dali::DaliException e) {
55905       {
55906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55907       };
55908     } catch (...) {
55909       {
55910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55911       };
55912     }
55913   }
55914
55915 }
55916
55917
55918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
55919   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
55920   Dali::Actor arg2 ;
55921   Dali::Actor *argp2 ;
55922
55923   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
55924   argp2 = (Dali::Actor *)jarg2;
55925   if (!argp2) {
55926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55927     return ;
55928   }
55929   arg2 = *argp2;
55930   {
55931     try {
55932       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
55933     } catch (std::out_of_range& e) {
55934       {
55935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55936       };
55937     } catch (std::exception& e) {
55938       {
55939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55940       };
55941     } catch (Dali::DaliException e) {
55942       {
55943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55944       };
55945     } catch (...) {
55946       {
55947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55948       };
55949     }
55950   }
55951
55952 }
55953
55954
55955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
55956   void * jresult ;
55957   Dali::Signal< void (Dali::Actor) > *result = 0 ;
55958
55959   {
55960     try {
55961       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
55962     } catch (std::out_of_range& e) {
55963       {
55964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55965       };
55966     } catch (std::exception& e) {
55967       {
55968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55969       };
55970     } catch (Dali::DaliException e) {
55971       {
55972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55973       };
55974     } catch (...) {
55975       {
55976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55977       };
55978     }
55979   }
55980
55981   jresult = (void *)result;
55982   return jresult;
55983 }
55984
55985
55986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
55987   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
55988
55989   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
55990   {
55991     try {
55992       delete arg1;
55993     } catch (std::out_of_range& e) {
55994       {
55995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55996       };
55997     } catch (std::exception& e) {
55998       {
55999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56000       };
56001     } catch (Dali::DaliException e) {
56002       {
56003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56004       };
56005     } catch (...) {
56006       {
56007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56008       };
56009     }
56010   }
56011
56012 }
56013
56014
56015 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
56016   unsigned int jresult ;
56017   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56018   bool result;
56019
56020   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56021   {
56022     try {
56023       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56024     } catch (std::out_of_range& e) {
56025       {
56026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56027       };
56028     } catch (std::exception& e) {
56029       {
56030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56031       };
56032     } catch (Dali::DaliException e) {
56033       {
56034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56035       };
56036     } catch (...) {
56037       {
56038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56039       };
56040     }
56041   }
56042
56043   jresult = result;
56044   return jresult;
56045 }
56046
56047
56048 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
56049   unsigned long jresult ;
56050   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56051   std::size_t result;
56052
56053   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56054   {
56055     try {
56056       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56057     } catch (std::out_of_range& e) {
56058       {
56059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56060       };
56061     } catch (std::exception& e) {
56062       {
56063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56064       };
56065     } catch (Dali::DaliException e) {
56066       {
56067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56068       };
56069     } catch (...) {
56070       {
56071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56072       };
56073     }
56074   }
56075
56076   jresult = (unsigned long)result;
56077   return jresult;
56078 }
56079
56080
56081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
56082   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56083   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56084
56085   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56086   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56087   {
56088     try {
56089       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56090     } catch (std::out_of_range& e) {
56091       {
56092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56093       };
56094     } catch (std::exception& e) {
56095       {
56096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56097       };
56098     } catch (Dali::DaliException e) {
56099       {
56100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56101       };
56102     } catch (...) {
56103       {
56104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56105       };
56106     }
56107   }
56108
56109 }
56110
56111
56112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
56113   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56114   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56115
56116   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56117   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56118   {
56119     try {
56120       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56121     } catch (std::out_of_range& e) {
56122       {
56123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56124       };
56125     } catch (std::exception& e) {
56126       {
56127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56128       };
56129     } catch (Dali::DaliException e) {
56130       {
56131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56132       };
56133     } catch (...) {
56134       {
56135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56136       };
56137     }
56138   }
56139
56140 }
56141
56142
56143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
56144   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56145   Dali::KeyEvent *arg2 = 0 ;
56146
56147   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56148   arg2 = (Dali::KeyEvent *)jarg2;
56149   if (!arg2) {
56150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56151     return ;
56152   }
56153   {
56154     try {
56155       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
56156     } catch (std::out_of_range& e) {
56157       {
56158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56159       };
56160     } catch (std::exception& e) {
56161       {
56162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56163       };
56164     } catch (Dali::DaliException e) {
56165       {
56166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56167       };
56168     } catch (...) {
56169       {
56170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56171       };
56172     }
56173   }
56174
56175 }
56176
56177
56178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
56179   void * jresult ;
56180   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
56181
56182   {
56183     try {
56184       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
56185     } catch (std::out_of_range& e) {
56186       {
56187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56188       };
56189     } catch (std::exception& e) {
56190       {
56191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56192       };
56193     } catch (Dali::DaliException e) {
56194       {
56195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56196       };
56197     } catch (...) {
56198       {
56199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56200       };
56201     }
56202   }
56203
56204   jresult = (void *)result;
56205   return jresult;
56206 }
56207
56208
56209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
56210   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56211
56212   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56213   {
56214     try {
56215       delete arg1;
56216     } catch (std::out_of_range& e) {
56217       {
56218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56219       };
56220     } catch (std::exception& e) {
56221       {
56222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56223       };
56224     } catch (Dali::DaliException e) {
56225       {
56226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56227       };
56228     } catch (...) {
56229       {
56230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56231       };
56232     }
56233   }
56234
56235 }
56236
56237
56238 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
56239   unsigned int jresult ;
56240   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56241   bool result;
56242
56243   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56244   {
56245     try {
56246       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56247     } catch (std::out_of_range& e) {
56248       {
56249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56250       };
56251     } catch (std::exception& e) {
56252       {
56253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56254       };
56255     } catch (Dali::DaliException e) {
56256       {
56257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56258       };
56259     } catch (...) {
56260       {
56261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56262       };
56263     }
56264   }
56265
56266   jresult = result;
56267   return jresult;
56268 }
56269
56270
56271 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
56272   unsigned long jresult ;
56273   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56274   std::size_t result;
56275
56276   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56277   {
56278     try {
56279       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56280     } catch (std::out_of_range& e) {
56281       {
56282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56283       };
56284     } catch (std::exception& e) {
56285       {
56286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56287       };
56288     } catch (Dali::DaliException e) {
56289       {
56290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56291       };
56292     } catch (...) {
56293       {
56294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56295       };
56296     }
56297   }
56298
56299   jresult = (unsigned long)result;
56300   return jresult;
56301 }
56302
56303
56304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
56305   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56306   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56307
56308   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56309   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56310   {
56311     try {
56312       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56313     } catch (std::out_of_range& e) {
56314       {
56315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56316       };
56317     } catch (std::exception& e) {
56318       {
56319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56320       };
56321     } catch (Dali::DaliException e) {
56322       {
56323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56324       };
56325     } catch (...) {
56326       {
56327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56328       };
56329     }
56330   }
56331
56332 }
56333
56334
56335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
56336   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56337   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56338
56339   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56340   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56341   {
56342     try {
56343       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56344     } catch (std::out_of_range& e) {
56345       {
56346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56347       };
56348     } catch (std::exception& e) {
56349       {
56350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56351       };
56352     } catch (Dali::DaliException e) {
56353       {
56354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56355       };
56356     } catch (...) {
56357       {
56358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56359       };
56360     }
56361   }
56362
56363 }
56364
56365
56366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
56367   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56368   Dali::TouchData *arg2 = 0 ;
56369
56370   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56371   arg2 = (Dali::TouchData *)jarg2;
56372   if (!arg2) {
56373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
56374     return ;
56375   }
56376   {
56377     try {
56378       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
56379     } catch (std::out_of_range& e) {
56380       {
56381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56382       };
56383     } catch (std::exception& e) {
56384       {
56385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56386       };
56387     } catch (Dali::DaliException e) {
56388       {
56389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56390       };
56391     } catch (...) {
56392       {
56393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56394       };
56395     }
56396   }
56397
56398 }
56399
56400
56401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
56402   void * jresult ;
56403   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
56404
56405   {
56406     try {
56407       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
56408     } catch (std::out_of_range& e) {
56409       {
56410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56411       };
56412     } catch (std::exception& e) {
56413       {
56414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56415       };
56416     } catch (Dali::DaliException e) {
56417       {
56418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56419       };
56420     } catch (...) {
56421       {
56422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56423       };
56424     }
56425   }
56426
56427   jresult = (void *)result;
56428   return jresult;
56429 }
56430
56431
56432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
56433   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56434
56435   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56436   {
56437     try {
56438       delete arg1;
56439     } catch (std::out_of_range& e) {
56440       {
56441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56442       };
56443     } catch (std::exception& e) {
56444       {
56445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56446       };
56447     } catch (Dali::DaliException e) {
56448       {
56449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56450       };
56451     } catch (...) {
56452       {
56453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56454       };
56455     }
56456   }
56457
56458 }
56459
56460
56461 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
56462   unsigned int jresult ;
56463   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56464   bool result;
56465
56466   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56467   {
56468     try {
56469       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56470     } catch (std::out_of_range& e) {
56471       {
56472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56473       };
56474     } catch (std::exception& e) {
56475       {
56476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56477       };
56478     } catch (Dali::DaliException e) {
56479       {
56480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56481       };
56482     } catch (...) {
56483       {
56484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56485       };
56486     }
56487   }
56488
56489   jresult = result;
56490   return jresult;
56491 }
56492
56493
56494 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
56495   unsigned long jresult ;
56496   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56497   std::size_t result;
56498
56499   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56500   {
56501     try {
56502       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56503     } catch (std::out_of_range& e) {
56504       {
56505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56506       };
56507     } catch (std::exception& e) {
56508       {
56509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56510       };
56511     } catch (Dali::DaliException e) {
56512       {
56513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56514       };
56515     } catch (...) {
56516       {
56517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56518       };
56519     }
56520   }
56521
56522   jresult = (unsigned long)result;
56523   return jresult;
56524 }
56525
56526
56527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
56528   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56529   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56530
56531   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56532   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56533   {
56534     try {
56535       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56536     } catch (std::out_of_range& e) {
56537       {
56538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56539       };
56540     } catch (std::exception& e) {
56541       {
56542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56543       };
56544     } catch (Dali::DaliException e) {
56545       {
56546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56547       };
56548     } catch (...) {
56549       {
56550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56551       };
56552     }
56553   }
56554
56555 }
56556
56557
56558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
56559   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56560   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56561
56562   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56563   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56564   {
56565     try {
56566       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56567     } catch (std::out_of_range& e) {
56568       {
56569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56570       };
56571     } catch (std::exception& e) {
56572       {
56573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56574       };
56575     } catch (Dali::DaliException e) {
56576       {
56577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56578       };
56579     } catch (...) {
56580       {
56581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56582       };
56583     }
56584   }
56585
56586 }
56587
56588
56589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
56590   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56591   Dali::WheelEvent *arg2 = 0 ;
56592
56593   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56594   arg2 = (Dali::WheelEvent *)jarg2;
56595   if (!arg2) {
56596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56597     return ;
56598   }
56599   {
56600     try {
56601       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
56602     } catch (std::out_of_range& e) {
56603       {
56604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56605       };
56606     } catch (std::exception& e) {
56607       {
56608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56609       };
56610     } catch (Dali::DaliException e) {
56611       {
56612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56613       };
56614     } catch (...) {
56615       {
56616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56617       };
56618     }
56619   }
56620
56621 }
56622
56623
56624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
56625   void * jresult ;
56626   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
56627
56628   {
56629     try {
56630       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
56631     } catch (std::out_of_range& e) {
56632       {
56633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56634       };
56635     } catch (std::exception& e) {
56636       {
56637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56638       };
56639     } catch (Dali::DaliException e) {
56640       {
56641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56642       };
56643     } catch (...) {
56644       {
56645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56646       };
56647     }
56648   }
56649
56650   jresult = (void *)result;
56651   return jresult;
56652 }
56653
56654
56655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
56656   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56657
56658   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56659   {
56660     try {
56661       delete arg1;
56662     } catch (std::out_of_range& e) {
56663       {
56664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56665       };
56666     } catch (std::exception& e) {
56667       {
56668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56669       };
56670     } catch (Dali::DaliException e) {
56671       {
56672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56673       };
56674     } catch (...) {
56675       {
56676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56677       };
56678     }
56679   }
56680
56681 }
56682
56683
56684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
56685   void * jresult ;
56686   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56687
56688   {
56689     try {
56690       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
56691     } catch (std::out_of_range& e) {
56692       {
56693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56694       };
56695     } catch (std::exception& e) {
56696       {
56697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56698       };
56699     } catch (Dali::DaliException e) {
56700       {
56701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56702       };
56703     } catch (...) {
56704       {
56705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56706       };
56707     }
56708   }
56709
56710   jresult = (void *)result;
56711   return jresult;
56712 }
56713
56714
56715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
56716   void * jresult ;
56717   Dali::Radian arg1 ;
56718   Dali::Radian arg2 ;
56719   Dali::Radian *argp1 ;
56720   Dali::Radian *argp2 ;
56721   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56722
56723   argp1 = (Dali::Radian *)jarg1;
56724   if (!argp1) {
56725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56726     return 0;
56727   }
56728   arg1 = *argp1;
56729   argp2 = (Dali::Radian *)jarg2;
56730   if (!argp2) {
56731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56732     return 0;
56733   }
56734   arg2 = *argp2;
56735   {
56736     try {
56737       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
56738     } catch (std::out_of_range& e) {
56739       {
56740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56741       };
56742     } catch (std::exception& e) {
56743       {
56744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56745       };
56746     } catch (Dali::DaliException e) {
56747       {
56748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56749       };
56750     } catch (...) {
56751       {
56752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56753       };
56754     }
56755   }
56756
56757   jresult = (void *)result;
56758   return jresult;
56759 }
56760
56761
56762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
56763   void * jresult ;
56764   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
56765   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56766
56767   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56768   if (!arg1) {
56769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
56770     return 0;
56771   }
56772   {
56773     try {
56774       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
56775     } catch (std::out_of_range& e) {
56776       {
56777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56778       };
56779     } catch (std::exception& e) {
56780       {
56781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56782       };
56783     } catch (Dali::DaliException e) {
56784       {
56785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56786       };
56787     } catch (...) {
56788       {
56789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56790       };
56791     }
56792   }
56793
56794   jresult = (void *)result;
56795   return jresult;
56796 }
56797
56798
56799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
56800   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56801   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
56802
56803   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56804   arg2 = (Dali::Radian *)jarg2;
56805   if (arg1) (arg1)->first = *arg2;
56806 }
56807
56808
56809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
56810   void * jresult ;
56811   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56812   Dali::Radian *result = 0 ;
56813
56814   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56815   result = (Dali::Radian *)& ((arg1)->first);
56816   jresult = (void *)result;
56817   return jresult;
56818 }
56819
56820
56821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
56822   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56823   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
56824
56825   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56826   arg2 = (Dali::Radian *)jarg2;
56827   if (arg1) (arg1)->second = *arg2;
56828 }
56829
56830
56831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
56832   void * jresult ;
56833   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56834   Dali::Radian *result = 0 ;
56835
56836   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56837   result = (Dali::Radian *)& ((arg1)->second);
56838   jresult = (void *)result;
56839   return jresult;
56840 }
56841
56842
56843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
56844   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56845
56846   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56847   {
56848     try {
56849       delete arg1;
56850     } catch (std::out_of_range& e) {
56851       {
56852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56853       };
56854     } catch (std::exception& e) {
56855       {
56856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56857       };
56858     } catch (Dali::DaliException e) {
56859       {
56860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56861       };
56862     } catch (...) {
56863       {
56864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56865       };
56866     }
56867   }
56868
56869 }
56870
56871
56872 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
56873   unsigned int jresult ;
56874   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
56875   bool result;
56876
56877   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
56878   {
56879     try {
56880       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);
56881     } catch (std::out_of_range& e) {
56882       {
56883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56884       };
56885     } catch (std::exception& e) {
56886       {
56887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56888       };
56889     } catch (Dali::DaliException e) {
56890       {
56891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56892       };
56893     } catch (...) {
56894       {
56895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56896       };
56897     }
56898   }
56899
56900   jresult = result;
56901   return jresult;
56902 }
56903
56904
56905 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
56906   unsigned long jresult ;
56907   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
56908   std::size_t result;
56909
56910   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
56911   {
56912     try {
56913       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);
56914     } catch (std::out_of_range& e) {
56915       {
56916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56917       };
56918     } catch (std::exception& e) {
56919       {
56920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56921       };
56922     } catch (Dali::DaliException e) {
56923       {
56924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56925       };
56926     } catch (...) {
56927       {
56928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56929       };
56930     }
56931   }
56932
56933   jresult = (unsigned long)result;
56934   return jresult;
56935 }
56936
56937
56938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
56939   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
56940   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
56941
56942   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
56943   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
56944   {
56945     try {
56946       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56947     } catch (std::out_of_range& e) {
56948       {
56949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56950       };
56951     } catch (std::exception& e) {
56952       {
56953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56954       };
56955     } catch (Dali::DaliException e) {
56956       {
56957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56958       };
56959     } catch (...) {
56960       {
56961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56962       };
56963     }
56964   }
56965
56966 }
56967
56968
56969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
56970   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
56971   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
56972
56973   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
56974   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
56975   {
56976     try {
56977       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56978     } catch (std::out_of_range& e) {
56979       {
56980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56981       };
56982     } catch (std::exception& e) {
56983       {
56984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56985       };
56986     } catch (Dali::DaliException e) {
56987       {
56988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56989       };
56990     } catch (...) {
56991       {
56992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56993       };
56994     }
56995   }
56996
56997 }
56998
56999
57000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57001   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57002   Dali::Actor arg2 ;
57003   Dali::PanGesture *arg3 = 0 ;
57004   Dali::Actor *argp2 ;
57005
57006   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57007   argp2 = (Dali::Actor *)jarg2;
57008   if (!argp2) {
57009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57010     return ;
57011   }
57012   arg2 = *argp2;
57013   arg3 = (Dali::PanGesture *)jarg3;
57014   if (!arg3) {
57015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
57016     return ;
57017   }
57018   {
57019     try {
57020       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
57021     } catch (std::out_of_range& e) {
57022       {
57023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57024       };
57025     } catch (std::exception& e) {
57026       {
57027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57028       };
57029     } catch (Dali::DaliException e) {
57030       {
57031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57032       };
57033     } catch (...) {
57034       {
57035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57036       };
57037     }
57038   }
57039
57040 }
57041
57042
57043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
57044   void * jresult ;
57045   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
57046
57047   {
57048     try {
57049       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
57050     } catch (std::out_of_range& e) {
57051       {
57052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57053       };
57054     } catch (std::exception& e) {
57055       {
57056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57057       };
57058     } catch (Dali::DaliException e) {
57059       {
57060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57061       };
57062     } catch (...) {
57063       {
57064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57065       };
57066     }
57067   }
57068
57069   jresult = (void *)result;
57070   return jresult;
57071 }
57072
57073
57074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
57075   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57076
57077   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57078   {
57079     try {
57080       delete arg1;
57081     } catch (std::out_of_range& e) {
57082       {
57083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57084       };
57085     } catch (std::exception& e) {
57086       {
57087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57088       };
57089     } catch (Dali::DaliException e) {
57090       {
57091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57092       };
57093     } catch (...) {
57094       {
57095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57096       };
57097     }
57098   }
57099
57100 }
57101
57102
57103 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
57104   unsigned int jresult ;
57105   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57106   bool result;
57107
57108   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57109   {
57110     try {
57111       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);
57112     } catch (std::out_of_range& e) {
57113       {
57114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57115       };
57116     } catch (std::exception& e) {
57117       {
57118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57119       };
57120     } catch (Dali::DaliException e) {
57121       {
57122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57123       };
57124     } catch (...) {
57125       {
57126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57127       };
57128     }
57129   }
57130
57131   jresult = result;
57132   return jresult;
57133 }
57134
57135
57136 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57137   unsigned long jresult ;
57138   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57139   std::size_t result;
57140
57141   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57142   {
57143     try {
57144       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);
57145     } catch (std::out_of_range& e) {
57146       {
57147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57148       };
57149     } catch (std::exception& e) {
57150       {
57151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57152       };
57153     } catch (Dali::DaliException e) {
57154       {
57155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57156       };
57157     } catch (...) {
57158       {
57159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57160       };
57161     }
57162   }
57163
57164   jresult = (unsigned long)result;
57165   return jresult;
57166 }
57167
57168
57169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57170   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57171   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57172
57173   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57174   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57175   {
57176     try {
57177       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57178     } catch (std::out_of_range& e) {
57179       {
57180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57181       };
57182     } catch (std::exception& e) {
57183       {
57184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57185       };
57186     } catch (Dali::DaliException e) {
57187       {
57188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57189       };
57190     } catch (...) {
57191       {
57192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57193       };
57194     }
57195   }
57196
57197 }
57198
57199
57200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57201   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57202   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57203
57204   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57205   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57206   {
57207     try {
57208       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57209     } catch (std::out_of_range& e) {
57210       {
57211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57212       };
57213     } catch (std::exception& e) {
57214       {
57215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57216       };
57217     } catch (Dali::DaliException e) {
57218       {
57219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57220       };
57221     } catch (...) {
57222       {
57223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57224       };
57225     }
57226   }
57227
57228 }
57229
57230
57231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57232   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57233   Dali::Actor arg2 ;
57234   Dali::PinchGesture *arg3 = 0 ;
57235   Dali::Actor *argp2 ;
57236
57237   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57238   argp2 = (Dali::Actor *)jarg2;
57239   if (!argp2) {
57240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57241     return ;
57242   }
57243   arg2 = *argp2;
57244   arg3 = (Dali::PinchGesture *)jarg3;
57245   if (!arg3) {
57246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
57247     return ;
57248   }
57249   {
57250     try {
57251       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
57252     } catch (std::out_of_range& e) {
57253       {
57254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57255       };
57256     } catch (std::exception& e) {
57257       {
57258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57259       };
57260     } catch (Dali::DaliException e) {
57261       {
57262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57263       };
57264     } catch (...) {
57265       {
57266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57267       };
57268     }
57269   }
57270
57271 }
57272
57273
57274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
57275   void * jresult ;
57276   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
57277
57278   {
57279     try {
57280       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
57281     } catch (std::out_of_range& e) {
57282       {
57283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57284       };
57285     } catch (std::exception& e) {
57286       {
57287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57288       };
57289     } catch (Dali::DaliException e) {
57290       {
57291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57292       };
57293     } catch (...) {
57294       {
57295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57296       };
57297     }
57298   }
57299
57300   jresult = (void *)result;
57301   return jresult;
57302 }
57303
57304
57305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
57306   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57307
57308   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57309   {
57310     try {
57311       delete arg1;
57312     } catch (std::out_of_range& e) {
57313       {
57314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57315       };
57316     } catch (std::exception& e) {
57317       {
57318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57319       };
57320     } catch (Dali::DaliException e) {
57321       {
57322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57323       };
57324     } catch (...) {
57325       {
57326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57327       };
57328     }
57329   }
57330
57331 }
57332
57333
57334 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
57335   unsigned int jresult ;
57336   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57337   bool result;
57338
57339   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57340   {
57341     try {
57342       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);
57343     } catch (std::out_of_range& e) {
57344       {
57345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57346       };
57347     } catch (std::exception& e) {
57348       {
57349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57350       };
57351     } catch (Dali::DaliException e) {
57352       {
57353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57354       };
57355     } catch (...) {
57356       {
57357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57358       };
57359     }
57360   }
57361
57362   jresult = result;
57363   return jresult;
57364 }
57365
57366
57367 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57368   unsigned long jresult ;
57369   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57370   std::size_t result;
57371
57372   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57373   {
57374     try {
57375       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);
57376     } catch (std::out_of_range& e) {
57377       {
57378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57379       };
57380     } catch (std::exception& e) {
57381       {
57382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57383       };
57384     } catch (Dali::DaliException e) {
57385       {
57386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57387       };
57388     } catch (...) {
57389       {
57390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57391       };
57392     }
57393   }
57394
57395   jresult = (unsigned long)result;
57396   return jresult;
57397 }
57398
57399
57400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57401   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57402   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57403
57404   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57405   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57406   {
57407     try {
57408       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57409     } catch (std::out_of_range& e) {
57410       {
57411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57412       };
57413     } catch (std::exception& e) {
57414       {
57415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57416       };
57417     } catch (Dali::DaliException e) {
57418       {
57419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57420       };
57421     } catch (...) {
57422       {
57423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57424       };
57425     }
57426   }
57427
57428 }
57429
57430
57431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57432   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57433   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57434
57435   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57436   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57437   {
57438     try {
57439       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57440     } catch (std::out_of_range& e) {
57441       {
57442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57443       };
57444     } catch (std::exception& e) {
57445       {
57446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57447       };
57448     } catch (Dali::DaliException e) {
57449       {
57450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57451       };
57452     } catch (...) {
57453       {
57454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57455       };
57456     }
57457   }
57458
57459 }
57460
57461
57462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57463   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57464   Dali::Actor arg2 ;
57465   Dali::TapGesture *arg3 = 0 ;
57466   Dali::Actor *argp2 ;
57467
57468   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57469   argp2 = (Dali::Actor *)jarg2;
57470   if (!argp2) {
57471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57472     return ;
57473   }
57474   arg2 = *argp2;
57475   arg3 = (Dali::TapGesture *)jarg3;
57476   if (!arg3) {
57477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
57478     return ;
57479   }
57480   {
57481     try {
57482       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
57483     } catch (std::out_of_range& e) {
57484       {
57485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57486       };
57487     } catch (std::exception& e) {
57488       {
57489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57490       };
57491     } catch (Dali::DaliException e) {
57492       {
57493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57494       };
57495     } catch (...) {
57496       {
57497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57498       };
57499     }
57500   }
57501
57502 }
57503
57504
57505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
57506   void * jresult ;
57507   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
57508
57509   {
57510     try {
57511       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
57512     } catch (std::out_of_range& e) {
57513       {
57514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57515       };
57516     } catch (std::exception& e) {
57517       {
57518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57519       };
57520     } catch (Dali::DaliException e) {
57521       {
57522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57523       };
57524     } catch (...) {
57525       {
57526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57527       };
57528     }
57529   }
57530
57531   jresult = (void *)result;
57532   return jresult;
57533 }
57534
57535
57536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
57537   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57538
57539   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57540   {
57541     try {
57542       delete arg1;
57543     } catch (std::out_of_range& e) {
57544       {
57545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57546       };
57547     } catch (std::exception& e) {
57548       {
57549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57550       };
57551     } catch (Dali::DaliException e) {
57552       {
57553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57554       };
57555     } catch (...) {
57556       {
57557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57558       };
57559     }
57560   }
57561
57562 }
57563
57564 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
57565   unsigned int jresult ;
57566   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57567   bool result;
57568
57569   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57570   {
57571     try {
57572       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57573     } catch (std::out_of_range& e) {
57574       {
57575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57576       };
57577     } catch (std::exception& e) {
57578       {
57579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57580       };
57581     } catch (Dali::DaliException e) {
57582       {
57583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57584       };
57585     } catch (...) {
57586       {
57587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57588       };
57589     }
57590   }
57591
57592   jresult = result;
57593   return jresult;
57594 }
57595
57596
57597 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
57598   unsigned long jresult ;
57599   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57600   std::size_t result;
57601
57602   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57603   {
57604     try {
57605       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57606     } catch (std::out_of_range& e) {
57607       {
57608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57609       };
57610     } catch (std::exception& e) {
57611       {
57612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57613       };
57614     } catch (Dali::DaliException e) {
57615       {
57616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57617       };
57618     } catch (...) {
57619       {
57620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57621       };
57622     }
57623   }
57624
57625   jresult = (unsigned long)result;
57626   return jresult;
57627 }
57628
57629
57630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
57631   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57632   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57633
57634   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57635   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57636   {
57637     try {
57638       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
57639     } catch (std::out_of_range& e) {
57640       {
57641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57642       };
57643     } catch (std::exception& e) {
57644       {
57645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57646       };
57647     } catch (Dali::DaliException e) {
57648       {
57649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57650       };
57651     } catch (...) {
57652       {
57653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57654       };
57655     }
57656   }
57657
57658 }
57659
57660
57661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
57662   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57663   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57664
57665   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57666   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57667   {
57668     try {
57669       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
57670     } catch (std::out_of_range& e) {
57671       {
57672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57673       };
57674     } catch (std::exception& e) {
57675       {
57676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57677       };
57678     } catch (Dali::DaliException e) {
57679       {
57680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57681       };
57682     } catch (...) {
57683       {
57684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57685       };
57686     }
57687   }
57688
57689 }
57690
57691
57692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
57693   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57694   Dali::ResourceImage arg2 ;
57695   Dali::ResourceImage *argp2 ;
57696
57697   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57698   argp2 = (Dali::ResourceImage *)jarg2;
57699   if (!argp2) {
57700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
57701     return ;
57702   }
57703   arg2 = *argp2;
57704   {
57705     try {
57706       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
57707     } catch (std::out_of_range& e) {
57708       {
57709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57710       };
57711     } catch (std::exception& e) {
57712       {
57713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57714       };
57715     } catch (Dali::DaliException e) {
57716       {
57717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57718       };
57719     } catch (...) {
57720       {
57721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57722       };
57723     }
57724   }
57725
57726 }
57727
57728
57729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
57730   void * jresult ;
57731   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
57732
57733   {
57734     try {
57735       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
57736     } catch (std::out_of_range& e) {
57737       {
57738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57739       };
57740     } catch (std::exception& e) {
57741       {
57742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57743       };
57744     } catch (Dali::DaliException e) {
57745       {
57746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57747       };
57748     } catch (...) {
57749       {
57750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57751       };
57752     }
57753   }
57754
57755   jresult = (void *)result;
57756   return jresult;
57757 }
57758
57759
57760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
57761   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57762
57763   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57764   {
57765     try {
57766       delete arg1;
57767     } catch (std::out_of_range& e) {
57768       {
57769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57770       };
57771     } catch (std::exception& e) {
57772       {
57773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57774       };
57775     } catch (Dali::DaliException e) {
57776       {
57777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57778       };
57779     } catch (...) {
57780       {
57781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57782       };
57783     }
57784   }
57785
57786 }
57787
57788 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
57789   unsigned int jresult ;
57790   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57791   bool result = false;
57792
57793   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57794   {
57795     try {
57796       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);
57797     } catch (std::out_of_range& e) {
57798       {
57799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57800       };
57801     } catch (std::exception& e) {
57802       {
57803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57804       };
57805     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
57806   }
57807   jresult = result;
57808   return jresult;
57809 }
57810
57811 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
57812   unsigned long jresult ;
57813   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57814   std::size_t result = 0;
57815
57816   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57817   {
57818     try {
57819       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);
57820     } catch (std::out_of_range& e) {
57821       {
57822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57823       };
57824     } catch (std::exception& e) {
57825       {
57826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57827       };
57828     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
57829   }
57830   jresult = (unsigned long)result;
57831   return jresult;
57832 }
57833
57834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
57835   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57836   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
57837
57838   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57839   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
57840   {
57841     try {
57842       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
57843     } catch (std::out_of_range& e) {
57844       {
57845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57846       };
57847     } catch (std::exception& e) {
57848       {
57849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57850       };
57851     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
57852   }
57853 }
57854
57855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
57856   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57857   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
57858
57859   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57860   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
57861   {
57862     try {
57863       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
57864     } catch (std::out_of_range& e) {
57865       {
57866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57867       };
57868     } catch (std::exception& e) {
57869       {
57870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57871       };
57872     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
57873   }
57874 }
57875
57876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
57877   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57878   Dali::Actor arg2 ;
57879   //bool arg3 ;
57880   Dali::LayoutDirection::Type arg4 ;
57881   Dali::Actor *argp2 ;
57882
57883   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57884   argp2 = (Dali::Actor *)jarg2;
57885   if (!argp2) {
57886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57887     return ;
57888   }
57889   arg2 = *argp2;
57890   //arg3 = jarg3 ? true : false;
57891   arg4 = (Dali::LayoutDirection::Type)jarg4;
57892   {
57893     try {
57894       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
57895     } catch (std::out_of_range& e) {
57896       {
57897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57898       };
57899     } catch (std::exception& e) {
57900       {
57901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57902       };
57903     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
57904   }
57905 }
57906
57907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
57908   void * jresult ;
57909   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
57910
57911   {
57912     try {
57913       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
57914     } catch (std::out_of_range& e) {
57915       {
57916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57917       };
57918     } catch (std::exception& e) {
57919       {
57920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57921       };
57922     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
57923   }
57924   jresult = (void *)result;
57925   return jresult;
57926 }
57927
57928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
57929   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57930
57931   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57932   {
57933     try {
57934       delete arg1;
57935     } catch (std::out_of_range& e) {
57936       {
57937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57938       };
57939     } catch (std::exception& e) {
57940       {
57941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57942       };
57943     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
57944   }
57945 }
57946
57947 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
57948   unsigned int jresult ;
57949   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
57950   bool result;
57951
57952   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
57953   {
57954     try {
57955       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);
57956     } catch (std::out_of_range& e) {
57957       {
57958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57959       };
57960     } catch (std::exception& e) {
57961       {
57962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57963       };
57964     } catch (Dali::DaliException e) {
57965       {
57966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57967       };
57968     } catch (...) {
57969       {
57970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57971       };
57972     }
57973   }
57974
57975   jresult = result;
57976   return jresult;
57977 }
57978
57979
57980 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
57981   unsigned long jresult ;
57982   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
57983   std::size_t result;
57984
57985   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
57986   {
57987     try {
57988       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);
57989     } catch (std::out_of_range& e) {
57990       {
57991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57992       };
57993     } catch (std::exception& e) {
57994       {
57995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57996       };
57997     } catch (Dali::DaliException e) {
57998       {
57999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58000       };
58001     } catch (...) {
58002       {
58003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58004       };
58005     }
58006   }
58007
58008   jresult = (unsigned long)result;
58009   return jresult;
58010 }
58011
58012
58013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
58014   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58015   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58016
58017   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58018   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58019   {
58020     try {
58021       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
58022     } catch (std::out_of_range& e) {
58023       {
58024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58025       };
58026     } catch (std::exception& e) {
58027       {
58028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58029       };
58030     } catch (Dali::DaliException e) {
58031       {
58032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58033       };
58034     } catch (...) {
58035       {
58036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58037       };
58038     }
58039   }
58040
58041 }
58042
58043
58044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
58045   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58046   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58047
58048   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58049   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58050   {
58051     try {
58052       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
58053     } catch (std::out_of_range& e) {
58054       {
58055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58056       };
58057     } catch (std::exception& e) {
58058       {
58059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58060       };
58061     } catch (Dali::DaliException e) {
58062       {
58063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58064       };
58065     } catch (...) {
58066       {
58067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58068       };
58069     }
58070   }
58071
58072 }
58073
58074
58075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
58076   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58077   Dali::Actor arg2 ;
58078   bool arg3 ;
58079   Dali::DevelActor::VisibilityChange::Type arg4 ;
58080   Dali::Actor *argp2 ;
58081
58082   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58083   argp2 = (Dali::Actor *)jarg2;
58084   if (!argp2) {
58085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58086     return ;
58087   }
58088   arg2 = *argp2;
58089   arg3 = jarg3 ? true : false;
58090   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
58091   {
58092     try {
58093       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
58094     } catch (std::out_of_range& e) {
58095       {
58096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58097       };
58098     } catch (std::exception& e) {
58099       {
58100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58101       };
58102     } catch (Dali::DaliException e) {
58103       {
58104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58105       };
58106     } catch (...) {
58107       {
58108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58109       };
58110     }
58111   }
58112
58113 }
58114
58115
58116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
58117   void * jresult ;
58118   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
58119
58120   {
58121     try {
58122       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
58123     } catch (std::out_of_range& e) {
58124       {
58125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58126       };
58127     } catch (std::exception& e) {
58128       {
58129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58130       };
58131     } catch (Dali::DaliException e) {
58132       {
58133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58134       };
58135     } catch (...) {
58136       {
58137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58138       };
58139     }
58140   }
58141
58142   jresult = (void *)result;
58143   return jresult;
58144 }
58145
58146
58147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
58148   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58149
58150   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58151   {
58152     try {
58153       delete arg1;
58154     } catch (std::out_of_range& e) {
58155       {
58156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58157       };
58158     } catch (std::exception& e) {
58159       {
58160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58161       };
58162     } catch (Dali::DaliException e) {
58163       {
58164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58165       };
58166     } catch (...) {
58167       {
58168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58169       };
58170     }
58171   }
58172
58173 }
58174
58175
58176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
58177   void * jresult ;
58178   Dali::Timer *result = 0 ;
58179
58180   {
58181     try {
58182       result = (Dali::Timer *)new Dali::Timer();
58183     } catch (std::out_of_range& e) {
58184       {
58185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58186       };
58187     } catch (std::exception& e) {
58188       {
58189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58190       };
58191     } catch (Dali::DaliException e) {
58192       {
58193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58194       };
58195     } catch (...) {
58196       {
58197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58198       };
58199     }
58200   }
58201
58202   jresult = (void *)result;
58203   return jresult;
58204 }
58205
58206
58207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
58208   void * jresult ;
58209   unsigned int arg1 ;
58210   Dali::Timer result;
58211
58212   arg1 = (unsigned int)jarg1;
58213   {
58214     try {
58215       result = Dali::Timer::New(arg1);
58216     } catch (std::out_of_range& e) {
58217       {
58218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58219       };
58220     } catch (std::exception& e) {
58221       {
58222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58223       };
58224     } catch (Dali::DaliException e) {
58225       {
58226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58227       };
58228     } catch (...) {
58229       {
58230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58231       };
58232     }
58233   }
58234
58235   jresult = new Dali::Timer((const Dali::Timer &)result);
58236   return jresult;
58237 }
58238
58239
58240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
58241   void * jresult ;
58242   Dali::Timer *arg1 = 0 ;
58243   Dali::Timer *result = 0 ;
58244
58245   arg1 = (Dali::Timer *)jarg1;
58246   if (!arg1) {
58247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58248     return 0;
58249   }
58250   {
58251     try {
58252       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
58253     } catch (std::out_of_range& e) {
58254       {
58255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58256       };
58257     } catch (std::exception& e) {
58258       {
58259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58260       };
58261     } catch (Dali::DaliException e) {
58262       {
58263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58264       };
58265     } catch (...) {
58266       {
58267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58268       };
58269     }
58270   }
58271
58272   jresult = (void *)result;
58273   return jresult;
58274 }
58275
58276
58277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
58278   void * jresult ;
58279   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58280   Dali::Timer *arg2 = 0 ;
58281   Dali::Timer *result = 0 ;
58282
58283   arg1 = (Dali::Timer *)jarg1;
58284   arg2 = (Dali::Timer *)jarg2;
58285   if (!arg2) {
58286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58287     return 0;
58288   }
58289   {
58290     try {
58291       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
58292     } catch (std::out_of_range& e) {
58293       {
58294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58295       };
58296     } catch (std::exception& e) {
58297       {
58298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58299       };
58300     } catch (Dali::DaliException e) {
58301       {
58302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58303       };
58304     } catch (...) {
58305       {
58306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58307       };
58308     }
58309   }
58310
58311   jresult = (void *)result;
58312   return jresult;
58313 }
58314
58315
58316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
58317   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58318
58319   arg1 = (Dali::Timer *)jarg1;
58320   {
58321     try {
58322       delete arg1;
58323     } catch (std::out_of_range& e) {
58324       {
58325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58326       };
58327     } catch (std::exception& e) {
58328       {
58329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58330       };
58331     } catch (Dali::DaliException e) {
58332       {
58333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58334       };
58335     } catch (...) {
58336       {
58337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58338       };
58339     }
58340   }
58341
58342 }
58343
58344
58345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
58346   void * jresult ;
58347   Dali::BaseHandle arg1 ;
58348   Dali::BaseHandle *argp1 ;
58349   Dali::Timer result;
58350
58351   argp1 = (Dali::BaseHandle *)jarg1;
58352   if (!argp1) {
58353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58354     return 0;
58355   }
58356   arg1 = *argp1;
58357   {
58358     try {
58359       result = Dali::Timer::DownCast(arg1);
58360     } catch (std::out_of_range& e) {
58361       {
58362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58363       };
58364     } catch (std::exception& e) {
58365       {
58366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58367       };
58368     } catch (Dali::DaliException e) {
58369       {
58370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58371       };
58372     } catch (...) {
58373       {
58374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58375       };
58376     }
58377   }
58378
58379   jresult = new Dali::Timer((const Dali::Timer &)result);
58380   return jresult;
58381 }
58382
58383
58384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
58385   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58386
58387   arg1 = (Dali::Timer *)jarg1;
58388   {
58389     try {
58390       (arg1)->Start();
58391     } catch (std::out_of_range& e) {
58392       {
58393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58394       };
58395     } catch (std::exception& e) {
58396       {
58397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58398       };
58399     } catch (Dali::DaliException e) {
58400       {
58401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58402       };
58403     } catch (...) {
58404       {
58405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58406       };
58407     }
58408   }
58409
58410 }
58411
58412
58413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
58414   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58415
58416   arg1 = (Dali::Timer *)jarg1;
58417   {
58418     try {
58419       (arg1)->Stop();
58420     } catch (std::out_of_range& e) {
58421       {
58422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58423       };
58424     } catch (std::exception& e) {
58425       {
58426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58427       };
58428     } catch (Dali::DaliException e) {
58429       {
58430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58431       };
58432     } catch (...) {
58433       {
58434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58435       };
58436     }
58437   }
58438
58439 }
58440
58441
58442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
58443   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58444   unsigned int arg2 ;
58445
58446   arg1 = (Dali::Timer *)jarg1;
58447   arg2 = (unsigned int)jarg2;
58448   {
58449     try {
58450       (arg1)->SetInterval(arg2);
58451     } catch (std::out_of_range& e) {
58452       {
58453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58454       };
58455     } catch (std::exception& e) {
58456       {
58457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58458       };
58459     } catch (Dali::DaliException e) {
58460       {
58461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58462       };
58463     } catch (...) {
58464       {
58465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58466       };
58467     }
58468   }
58469
58470 }
58471
58472
58473 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
58474   unsigned int jresult ;
58475   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58476   unsigned int result;
58477
58478   arg1 = (Dali::Timer *)jarg1;
58479   {
58480     try {
58481       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
58482     } catch (std::out_of_range& e) {
58483       {
58484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58485       };
58486     } catch (std::exception& e) {
58487       {
58488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58489       };
58490     } catch (Dali::DaliException e) {
58491       {
58492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58493       };
58494     } catch (...) {
58495       {
58496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58497       };
58498     }
58499   }
58500
58501   jresult = result;
58502   return jresult;
58503 }
58504
58505
58506 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
58507   unsigned int jresult ;
58508   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58509   bool result;
58510
58511   arg1 = (Dali::Timer *)jarg1;
58512   {
58513     try {
58514       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
58515     } catch (std::out_of_range& e) {
58516       {
58517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58518       };
58519     } catch (std::exception& e) {
58520       {
58521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58522       };
58523     } catch (Dali::DaliException e) {
58524       {
58525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58526       };
58527     } catch (...) {
58528       {
58529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58530       };
58531     }
58532   }
58533
58534   jresult = result;
58535   return jresult;
58536 }
58537
58538
58539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
58540   void * jresult ;
58541   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58542   Dali::Timer::TimerSignalType *result = 0 ;
58543
58544   arg1 = (Dali::Timer *)jarg1;
58545   {
58546     try {
58547       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
58548     } catch (std::out_of_range& e) {
58549       {
58550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58551       };
58552     } catch (std::exception& e) {
58553       {
58554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58555       };
58556     } catch (Dali::DaliException e) {
58557       {
58558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58559       };
58560     } catch (...) {
58561       {
58562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58563       };
58564     }
58565   }
58566
58567   jresult = (void *)result;
58568   return jresult;
58569 }
58570
58571
58572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DragAndDropDetector() {
58573   void * jresult ;
58574   Dali::DragAndDropDetector *result = 0 ;
58575
58576   {
58577     try {
58578       result = (Dali::DragAndDropDetector *)new Dali::DragAndDropDetector();
58579     } catch (std::out_of_range& e) {
58580       {
58581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58582       };
58583     } catch (std::exception& e) {
58584       {
58585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58586       };
58587     } catch (Dali::DaliException e) {
58588       {
58589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58590       };
58591     } catch (...) {
58592       {
58593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58594       };
58595     }
58596   }
58597
58598   jresult = (void *)result;
58599   return jresult;
58600 }
58601
58602
58603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DragAndDropDetector(void * jarg1) {
58604   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58605
58606   arg1 = (Dali::DragAndDropDetector *)jarg1;
58607   {
58608     try {
58609       delete arg1;
58610     } catch (std::out_of_range& e) {
58611       {
58612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58613       };
58614     } catch (std::exception& e) {
58615       {
58616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58617       };
58618     } catch (Dali::DaliException e) {
58619       {
58620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58621       };
58622     } catch (...) {
58623       {
58624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58625       };
58626     }
58627   }
58628
58629 }
58630
58631
58632 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetContent(void * jarg1) {
58633   char * jresult ;
58634   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58635   std::string *result = 0 ;
58636
58637   arg1 = (Dali::DragAndDropDetector *)jarg1;
58638   {
58639     try {
58640       result = (std::string *) &((Dali::DragAndDropDetector const *)arg1)->GetContent();
58641     } catch (std::out_of_range& e) {
58642       {
58643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58644       };
58645     } catch (std::exception& e) {
58646       {
58647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58648       };
58649     } catch (Dali::DaliException e) {
58650       {
58651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58652       };
58653     } catch (...) {
58654       {
58655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58656       };
58657     }
58658   }
58659
58660   jresult = SWIG_csharp_string_callback(result->c_str());
58661   return jresult;
58662 }
58663
58664
58665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetCurrentScreenPosition(void * jarg1) {
58666   void * jresult ;
58667   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58668   Dali::Vector2 result;
58669
58670   arg1 = (Dali::DragAndDropDetector *)jarg1;
58671   {
58672     try {
58673       result = ((Dali::DragAndDropDetector const *)arg1)->GetCurrentScreenPosition();
58674     } catch (std::out_of_range& e) {
58675       {
58676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58677       };
58678     } catch (std::exception& e) {
58679       {
58680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58681       };
58682     } catch (Dali::DaliException e) {
58683       {
58684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58685       };
58686     } catch (...) {
58687       {
58688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58689       };
58690     }
58691   }
58692
58693   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
58694   return jresult;
58695 }
58696
58697
58698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_EnteredSignal(void * jarg1) {
58699   void * jresult ;
58700   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58701   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58702
58703   arg1 = (Dali::DragAndDropDetector *)jarg1;
58704   {
58705     try {
58706       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->EnteredSignal();
58707     } catch (std::out_of_range& e) {
58708       {
58709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58710       };
58711     } catch (std::exception& e) {
58712       {
58713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58714       };
58715     } catch (Dali::DaliException e) {
58716       {
58717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58718       };
58719     } catch (...) {
58720       {
58721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58722       };
58723     }
58724   }
58725
58726   jresult = (void *)result;
58727   return jresult;
58728 }
58729
58730
58731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_ExitedSignal(void * jarg1) {
58732   void * jresult ;
58733   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58734   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58735
58736   arg1 = (Dali::DragAndDropDetector *)jarg1;
58737   {
58738     try {
58739       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->ExitedSignal();
58740     } catch (std::out_of_range& e) {
58741       {
58742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58743       };
58744     } catch (std::exception& e) {
58745       {
58746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58747       };
58748     } catch (Dali::DaliException e) {
58749       {
58750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58751       };
58752     } catch (...) {
58753       {
58754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58755       };
58756     }
58757   }
58758
58759   jresult = (void *)result;
58760   return jresult;
58761 }
58762
58763
58764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_MovedSignal(void * jarg1) {
58765   void * jresult ;
58766   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58767   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58768
58769   arg1 = (Dali::DragAndDropDetector *)jarg1;
58770   {
58771     try {
58772       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->MovedSignal();
58773     } catch (std::out_of_range& e) {
58774       {
58775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58776       };
58777     } catch (std::exception& e) {
58778       {
58779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58780       };
58781     } catch (Dali::DaliException e) {
58782       {
58783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58784       };
58785     } catch (...) {
58786       {
58787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58788       };
58789     }
58790   }
58791
58792   jresult = (void *)result;
58793   return jresult;
58794 }
58795
58796
58797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_DroppedSignal(void * jarg1) {
58798   void * jresult ;
58799   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58800   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58801
58802   arg1 = (Dali::DragAndDropDetector *)jarg1;
58803   {
58804     try {
58805       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->DroppedSignal();
58806     } catch (std::out_of_range& e) {
58807       {
58808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58809       };
58810     } catch (std::exception& e) {
58811       {
58812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58813       };
58814     } catch (Dali::DaliException e) {
58815       {
58816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58817       };
58818     } catch (...) {
58819       {
58820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58821       };
58822     }
58823   }
58824
58825   jresult = (void *)result;
58826   return jresult;
58827 }
58828
58829
58830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_0() {
58831   void * jresult ;
58832   Dali::ApplicationExtensions *result = 0 ;
58833
58834   {
58835     try {
58836       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions();
58837     } catch (std::out_of_range& e) {
58838       {
58839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58840       };
58841     } catch (std::exception& e) {
58842       {
58843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58844       };
58845     } catch (Dali::DaliException e) {
58846       {
58847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58848       };
58849     } catch (...) {
58850       {
58851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58852       };
58853     }
58854   }
58855
58856   jresult = (void *)result;
58857   return jresult;
58858 }
58859
58860
58861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_1(void * jarg1) {
58862   void * jresult ;
58863   Dali::Application *arg1 = (Dali::Application *) 0 ;
58864   Dali::ApplicationExtensions *result = 0 ;
58865
58866   arg1 = (Dali::Application *)jarg1;
58867   {
58868     try {
58869       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions(arg1);
58870     } catch (std::out_of_range& e) {
58871       {
58872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58873       };
58874     } catch (std::exception& e) {
58875       {
58876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58877       };
58878     } catch (Dali::DaliException e) {
58879       {
58880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58881       };
58882     } catch (...) {
58883       {
58884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58885       };
58886     }
58887   }
58888
58889   jresult = (void *)result;
58890   return jresult;
58891 }
58892
58893
58894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationExtensions(void * jarg1) {
58895   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
58896
58897   arg1 = (Dali::ApplicationExtensions *)jarg1;
58898   {
58899     try {
58900       delete arg1;
58901     } catch (std::out_of_range& e) {
58902       {
58903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58904       };
58905     } catch (std::exception& e) {
58906       {
58907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58908       };
58909     } catch (Dali::DaliException e) {
58910       {
58911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58912       };
58913     } catch (...) {
58914       {
58915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58916       };
58917     }
58918   }
58919
58920 }
58921
58922
58923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Init(void * jarg1) {
58924   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
58925
58926   arg1 = (Dali::ApplicationExtensions *)jarg1;
58927   {
58928     try {
58929       (arg1)->Init();
58930     } catch (std::out_of_range& e) {
58931       {
58932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58933       };
58934     } catch (std::exception& e) {
58935       {
58936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58937       };
58938     } catch (Dali::DaliException e) {
58939       {
58940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58941       };
58942     } catch (...) {
58943       {
58944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58945       };
58946     }
58947   }
58948
58949 }
58950
58951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Start(void * jarg1) {
58952   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
58953
58954   arg1 = (Dali::ApplicationExtensions *)jarg1;
58955   {
58956     try {
58957       (arg1)->Start();
58958     } catch (std::out_of_range& e) {
58959       {
58960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58961       };
58962     } catch (std::exception& e) {
58963       {
58964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58965       };
58966     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }
58967   }
58968 }
58969
58970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Terminate(void * jarg1) {
58971   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
58972
58973   arg1 = (Dali::ApplicationExtensions *)jarg1;
58974   {
58975     try {
58976       (arg1)->Terminate();
58977     } catch (std::out_of_range& e) {
58978       {
58979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58980       };
58981     } catch (std::exception& e) {
58982       {
58983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58984       };
58985     } catch (Dali::DaliException e) {
58986       {
58987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58988       };
58989     } catch (...) {
58990       {
58991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58992       };
58993     }
58994   }
58995
58996 }
58997
58998
58999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Pause(void * jarg1) {
59000   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59001
59002   arg1 = (Dali::ApplicationExtensions *)jarg1;
59003   {
59004     try {
59005       (arg1)->Pause();
59006     } catch (std::out_of_range& e) {
59007       {
59008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59009       };
59010     } catch (std::exception& e) {
59011       {
59012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59013       };
59014     } catch (Dali::DaliException e) {
59015       {
59016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59017       };
59018     } catch (...) {
59019       {
59020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59021       };
59022     }
59023   }
59024
59025 }
59026
59027
59028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Resume(void * jarg1) {
59029   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59030
59031   arg1 = (Dali::ApplicationExtensions *)jarg1;
59032   {
59033     try {
59034       (arg1)->Resume();
59035     } catch (std::out_of_range& e) {
59036       {
59037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59038       };
59039     } catch (std::exception& e) {
59040       {
59041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59042       };
59043     } catch (Dali::DaliException e) {
59044       {
59045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59046       };
59047     } catch (...) {
59048       {
59049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59050       };
59051     }
59052   }
59053
59054 }
59055
59056
59057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_LanguageChange(void * jarg1) {
59058   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59059
59060   arg1 = (Dali::ApplicationExtensions *)jarg1;
59061   {
59062     try {
59063       (arg1)->LanguageChange();
59064     } catch (std::out_of_range& e) {
59065       {
59066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59067       };
59068     } catch (std::exception& e) {
59069       {
59070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59071       };
59072     } catch (Dali::DaliException e) {
59073       {
59074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59075       };
59076     } catch (...) {
59077       {
59078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59079       };
59080     }
59081   }
59082
59083 }
59084
59085
59086
59087 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
59088   unsigned int jresult ;
59089   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59090   bool result;
59091
59092   arg1 = (Dali::Signal< bool () > *)jarg1;
59093   {
59094     try {
59095       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
59096     } catch (std::out_of_range& e) {
59097       {
59098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59099       };
59100     } catch (std::exception& e) {
59101       {
59102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59103       };
59104     } catch (Dali::DaliException e) {
59105       {
59106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59107       };
59108     } catch (...) {
59109       {
59110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59111       };
59112     }
59113   }
59114
59115   jresult = result;
59116   return jresult;
59117 }
59118
59119
59120 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
59121   unsigned long jresult ;
59122   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59123   std::size_t result;
59124
59125   arg1 = (Dali::Signal< bool () > *)jarg1;
59126   {
59127     try {
59128       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
59129     } catch (std::out_of_range& e) {
59130       {
59131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59132       };
59133     } catch (std::exception& e) {
59134       {
59135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59136       };
59137     } catch (Dali::DaliException e) {
59138       {
59139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59140       };
59141     } catch (...) {
59142       {
59143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59144       };
59145     }
59146   }
59147
59148   jresult = (unsigned long)result;
59149   return jresult;
59150 }
59151
59152
59153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
59154   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59155   bool (*arg2)() = (bool (*)()) 0 ;
59156
59157   arg1 = (Dali::Signal< bool () > *)jarg1;
59158   arg2 = (bool (*)())jarg2;
59159   {
59160     try {
59161       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
59162     } catch (std::out_of_range& e) {
59163       {
59164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59165       };
59166     } catch (std::exception& e) {
59167       {
59168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59169       };
59170     } catch (Dali::DaliException e) {
59171       {
59172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59173       };
59174     } catch (...) {
59175       {
59176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59177       };
59178     }
59179   }
59180
59181 }
59182
59183
59184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
59185   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59186   bool (*arg2)() = (bool (*)()) 0 ;
59187
59188   arg1 = (Dali::Signal< bool () > *)jarg1;
59189   arg2 = (bool (*)())jarg2;
59190   {
59191     try {
59192       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
59193     } catch (std::out_of_range& e) {
59194       {
59195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59196       };
59197     } catch (std::exception& e) {
59198       {
59199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59200       };
59201     } catch (Dali::DaliException e) {
59202       {
59203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59204       };
59205     } catch (...) {
59206       {
59207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59208       };
59209     }
59210   }
59211
59212 }
59213
59214
59215 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
59216   unsigned int jresult ;
59217   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59218   bool result;
59219
59220   arg1 = (Dali::Signal< bool () > *)jarg1;
59221   {
59222     try {
59223       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
59224     } catch (std::out_of_range& e) {
59225       {
59226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59227       };
59228     } catch (std::exception& e) {
59229       {
59230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59231       };
59232     } catch (Dali::DaliException e) {
59233       {
59234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59235       };
59236     } catch (...) {
59237       {
59238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59239       };
59240     }
59241   }
59242
59243   jresult = result;
59244   return jresult;
59245 }
59246
59247
59248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
59249   void * jresult ;
59250   Dali::Signal< bool () > *result = 0 ;
59251
59252   {
59253     try {
59254       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
59255     } catch (std::out_of_range& e) {
59256       {
59257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59258       };
59259     } catch (std::exception& e) {
59260       {
59261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59262       };
59263     } catch (Dali::DaliException e) {
59264       {
59265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59266       };
59267     } catch (...) {
59268       {
59269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59270       };
59271     }
59272   }
59273
59274   jresult = (void *)result;
59275   return jresult;
59276 }
59277
59278
59279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
59280   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59281
59282   arg1 = (Dali::Signal< bool () > *)jarg1;
59283   {
59284     try {
59285       delete arg1;
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 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
59309   int jresult ;
59310   int result;
59311
59312   {
59313     try {
59314       result = (int)Dali::Toolkit::Visual::Property::TYPE;
59315     } catch (std::out_of_range& e) {
59316       {
59317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59318       };
59319     } catch (std::exception& e) {
59320       {
59321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59322       };
59323     } catch (Dali::DaliException e) {
59324       {
59325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59326       };
59327     } catch (...) {
59328       {
59329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59330       };
59331     }
59332   }
59333
59334   jresult = (int)result;
59335   return jresult;
59336 }
59337
59338
59339 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
59340   int jresult ;
59341   int result;
59342
59343   {
59344     try {
59345       result = (int)Dali::Toolkit::Visual::Property::SHADER;
59346     } catch (std::out_of_range& e) {
59347       {
59348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59349       };
59350     } catch (std::exception& e) {
59351       {
59352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59353       };
59354     } catch (Dali::DaliException e) {
59355       {
59356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59357       };
59358     } catch (...) {
59359       {
59360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59361       };
59362     }
59363   }
59364
59365   jresult = (int)result;
59366   return jresult;
59367 }
59368
59369
59370 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
59371   int jresult ;
59372   int result;
59373
59374   {
59375     try {
59376       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
59377     } catch (std::out_of_range& e) {
59378       {
59379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59380       };
59381     } catch (std::exception& e) {
59382       {
59383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59384       };
59385     } catch (Dali::DaliException e) {
59386       {
59387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59388       };
59389     } catch (...) {
59390       {
59391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59392       };
59393     }
59394   }
59395
59396   jresult = (int)result;
59397   return jresult;
59398 }
59399
59400
59401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
59402   int jresult ;
59403   int result;
59404
59405   {
59406     try {
59407       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
59408     } catch (std::out_of_range& e) {
59409       {
59410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59411       };
59412     } catch (std::exception& e) {
59413       {
59414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59415       };
59416     } catch (Dali::DaliException e) {
59417       {
59418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59419       };
59420     } catch (...) {
59421       {
59422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59423       };
59424     }
59425   }
59426
59427   jresult = (int)result;
59428   return jresult;
59429 }
59430
59431
59432 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
59433   int jresult ;
59434   int result;
59435
59436   {
59437     try {
59438       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
59439     } catch (std::out_of_range& e) {
59440       {
59441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59442       };
59443     } catch (std::exception& e) {
59444       {
59445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59446       };
59447     } catch (Dali::DaliException e) {
59448       {
59449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59450       };
59451     } catch (...) {
59452       {
59453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59454       };
59455     }
59456   }
59457
59458   jresult = (int)result;
59459   return jresult;
59460 }
59461
59462
59463 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
59464   int jresult ;
59465   int result;
59466
59467   {
59468     try {
59469       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
59470     } catch (std::out_of_range& e) {
59471       {
59472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59473       };
59474     } catch (std::exception& e) {
59475       {
59476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59477       };
59478     } catch (Dali::DaliException e) {
59479       {
59480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59481       };
59482     } catch (...) {
59483       {
59484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59485       };
59486     }
59487   }
59488
59489   jresult = (int)result;
59490   return jresult;
59491 }
59492
59493
59494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
59495   int jresult ;
59496   int result;
59497
59498   {
59499     try {
59500       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
59501     } catch (std::out_of_range& e) {
59502       {
59503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59504       };
59505     } catch (std::exception& e) {
59506       {
59507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59508       };
59509     } catch (Dali::DaliException e) {
59510       {
59511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59512       };
59513     } catch (...) {
59514       {
59515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59516       };
59517     }
59518   }
59519
59520   jresult = (int)result;
59521   return jresult;
59522 }
59523
59524
59525 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
59526   int jresult ;
59527   int result;
59528
59529   {
59530     try {
59531       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
59532     } catch (std::out_of_range& e) {
59533       {
59534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59535       };
59536     } catch (std::exception& e) {
59537       {
59538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59539       };
59540     } catch (Dali::DaliException e) {
59541       {
59542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59543       };
59544     } catch (...) {
59545       {
59546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59547       };
59548     }
59549   }
59550
59551   jresult = (int)result;
59552   return jresult;
59553 }
59554
59555
59556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
59557   int jresult ;
59558   int result;
59559
59560   {
59561     try {
59562       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
59563     } catch (std::out_of_range& e) {
59564       {
59565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59566       };
59567     } catch (std::exception& e) {
59568       {
59569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59570       };
59571     } catch (Dali::DaliException e) {
59572       {
59573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59574       };
59575     } catch (...) {
59576       {
59577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59578       };
59579     }
59580   }
59581
59582   jresult = (int)result;
59583   return jresult;
59584 }
59585
59586
59587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
59588   int jresult ;
59589   int result;
59590
59591   {
59592     try {
59593       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
59594     } catch (std::out_of_range& e) {
59595       {
59596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59597       };
59598     } catch (std::exception& e) {
59599       {
59600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59601       };
59602     } catch (Dali::DaliException e) {
59603       {
59604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59605       };
59606     } catch (...) {
59607       {
59608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59609       };
59610     }
59611   }
59612
59613   jresult = (int)result;
59614   return jresult;
59615 }
59616
59617
59618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
59619   int jresult ;
59620   int result;
59621
59622   {
59623     try {
59624       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
59625     } catch (std::out_of_range& e) {
59626       {
59627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59628       };
59629     } catch (std::exception& e) {
59630       {
59631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59632       };
59633     } catch (Dali::DaliException e) {
59634       {
59635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59636       };
59637     } catch (...) {
59638       {
59639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59640       };
59641     }
59642   }
59643
59644   jresult = (int)result;
59645   return jresult;
59646 }
59647
59648
59649 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
59650   int jresult ;
59651   int result;
59652
59653   {
59654     try {
59655       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
59656     } catch (std::out_of_range& e) {
59657       {
59658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59659       };
59660     } catch (std::exception& e) {
59661       {
59662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59663       };
59664     } catch (Dali::DaliException e) {
59665       {
59666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59667       };
59668     } catch (...) {
59669       {
59670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59671       };
59672     }
59673   }
59674
59675   jresult = (int)result;
59676   return jresult;
59677 }
59678
59679
59680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
59681   int jresult ;
59682   int result;
59683
59684   {
59685     try {
59686       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
59687     } catch (std::out_of_range& e) {
59688       {
59689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59690       };
59691     } catch (std::exception& e) {
59692       {
59693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59694       };
59695     } catch (Dali::DaliException e) {
59696       {
59697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59698       };
59699     } catch (...) {
59700       {
59701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59702       };
59703     }
59704   }
59705
59706   jresult = (int)result;
59707   return jresult;
59708 }
59709
59710
59711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
59712   int jresult ;
59713   int result;
59714
59715   {
59716     try {
59717       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
59718     } catch (std::out_of_range& e) {
59719       {
59720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59721       };
59722     } catch (std::exception& e) {
59723       {
59724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59725       };
59726     } catch (Dali::DaliException e) {
59727       {
59728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59729       };
59730     } catch (...) {
59731       {
59732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59733       };
59734     }
59735   }
59736
59737   jresult = (int)result;
59738   return jresult;
59739 }
59740
59741
59742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
59743   int jresult ;
59744   int result;
59745
59746   {
59747     try {
59748       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
59749     } catch (std::out_of_range& e) {
59750       {
59751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59752       };
59753     } catch (std::exception& e) {
59754       {
59755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59756       };
59757     } catch (Dali::DaliException e) {
59758       {
59759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59760       };
59761     } catch (...) {
59762       {
59763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59764       };
59765     }
59766   }
59767
59768   jresult = (int)result;
59769   return jresult;
59770 }
59771
59772
59773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
59774   int jresult ;
59775   int result;
59776
59777   {
59778     try {
59779       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
59780     } catch (std::out_of_range& e) {
59781       {
59782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59783       };
59784     } catch (std::exception& e) {
59785       {
59786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59787       };
59788     } catch (Dali::DaliException e) {
59789       {
59790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59791       };
59792     } catch (...) {
59793       {
59794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59795       };
59796     }
59797   }
59798
59799   jresult = (int)result;
59800   return jresult;
59801 }
59802
59803
59804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
59805   int jresult ;
59806   int result;
59807
59808   {
59809     try {
59810       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
59811     } catch (std::out_of_range& e) {
59812       {
59813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59814       };
59815     } catch (std::exception& e) {
59816       {
59817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59818       };
59819     } catch (Dali::DaliException e) {
59820       {
59821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59822       };
59823     } catch (...) {
59824       {
59825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59826       };
59827     }
59828   }
59829
59830   jresult = (int)result;
59831   return jresult;
59832 }
59833
59834
59835 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
59836   int jresult ;
59837   int result;
59838
59839   {
59840     try {
59841       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
59842     } catch (std::out_of_range& e) {
59843       {
59844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59845       };
59846     } catch (std::exception& e) {
59847       {
59848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59849       };
59850     } catch (Dali::DaliException e) {
59851       {
59852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59853       };
59854     } catch (...) {
59855       {
59856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59857       };
59858     }
59859   }
59860
59861   jresult = (int)result;
59862   return jresult;
59863 }
59864
59865
59866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
59867   int jresult ;
59868   int result;
59869
59870   {
59871     try {
59872       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
59873     } catch (std::out_of_range& e) {
59874       {
59875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59876       };
59877     } catch (std::exception& e) {
59878       {
59879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59880       };
59881     } catch (Dali::DaliException e) {
59882       {
59883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59884       };
59885     } catch (...) {
59886       {
59887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59888       };
59889     }
59890   }
59891
59892   jresult = (int)result;
59893   return jresult;
59894 }
59895
59896
59897 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
59898   int jresult ;
59899   int result;
59900
59901   {
59902     try {
59903       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
59904     } catch (std::out_of_range& e) {
59905       {
59906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59907       };
59908     } catch (std::exception& e) {
59909       {
59910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59911       };
59912     } catch (Dali::DaliException e) {
59913       {
59914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59915       };
59916     } catch (...) {
59917       {
59918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59919       };
59920     }
59921   }
59922
59923   jresult = (int)result;
59924   return jresult;
59925 }
59926
59927 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
59928   int jresult ;
59929   int result;
59930
59931   {
59932     try {
59933       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
59934     } catch (std::out_of_range& e) {
59935       {
59936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59937       };
59938     } catch (std::exception& e) {
59939       {
59940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59941       };
59942     } catch (Dali::DaliException e) {
59943       {
59944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59945       };
59946     } catch (...) {
59947       {
59948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59949       };
59950     }
59951   }
59952
59953   jresult = (int)result;
59954   return jresult;
59955 }
59956
59957
59958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
59959   int jresult ;
59960   int result;
59961   {
59962     try
59963     {
59964       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
59965     } catch (std::out_of_range& e) {
59966       {
59967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59968       };
59969     } catch (std::exception& e) {
59970       {
59971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59972       };
59973     } catch (Dali::DaliException e) {
59974       {
59975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59976       };
59977     } catch (...) {
59978       {
59979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59980       };
59981     }
59982   }
59983
59984   jresult = (int)result;
59985   return jresult;
59986 }
59987
59988 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
59989   int jresult ;
59990   int result;
59991   {
59992     try
59993     {
59994       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
59995     } catch (std::out_of_range& e) {
59996       {
59997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59998       };
59999     } catch (std::exception& e) {
60000       {
60001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60002       };
60003     } catch (Dali::DaliException e) {
60004       {
60005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60006       };
60007     } catch (...) {
60008       {
60009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60010       };
60011     }
60012   }
60013
60014   jresult = (int)result;
60015   return jresult;
60016 }
60017
60018 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
60019   int jresult ;
60020   int result;
60021   {
60022     try
60023     {
60024       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
60025     } catch (std::out_of_range& e) {
60026       {
60027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60028       };
60029     } catch (std::exception& e) {
60030       {
60031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60032       };
60033     } catch (Dali::DaliException e) {
60034       {
60035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60036       };
60037     } catch (...) {
60038       {
60039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60040       };
60041     }
60042   }
60043
60044   jresult = (int)result;
60045   return jresult;
60046 }
60047
60048 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
60049   int jresult ;
60050   int result;
60051   {
60052     try
60053     {
60054       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
60055     } catch (std::out_of_range& e) {
60056       {
60057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60058       };
60059     } catch (std::exception& e) {
60060       {
60061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60062       };
60063     } catch (Dali::DaliException e) {
60064       {
60065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60066       };
60067     } catch (...) {
60068       {
60069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60070       };
60071     }
60072   }
60073
60074   jresult = (int)result;
60075   return jresult;
60076 }
60077
60078 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
60079   int jresult ;
60080   int result;
60081   {
60082     try
60083     {
60084       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
60085     } catch (std::out_of_range& e) {
60086       {
60087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60088       };
60089     } catch (std::exception& e) {
60090       {
60091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60092       };
60093     } catch (Dali::DaliException e) {
60094       {
60095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60096       };
60097     } catch (...) {
60098       {
60099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60100       };
60101     }
60102   }
60103
60104   jresult = (int)result;
60105   return jresult;
60106 }
60107
60108 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
60109   int jresult ;
60110   int result;
60111
60112   {
60113     try {
60114       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
60115     } catch (std::out_of_range& e) {
60116       {
60117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60118       };
60119     } catch (std::exception& e) {
60120       {
60121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60122       };
60123     } catch (Dali::DaliException e) {
60124       {
60125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60126       };
60127     } catch (...) {
60128       {
60129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60130       };
60131     }
60132   }
60133
60134   jresult = (int)result;
60135   return jresult;
60136 }
60137
60138
60139 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
60140   int jresult ;
60141   int result;
60142
60143   {
60144     try {
60145       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
60146     } catch (std::out_of_range& e) {
60147       {
60148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60149       };
60150     } catch (std::exception& e) {
60151       {
60152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60153       };
60154     } catch (Dali::DaliException e) {
60155       {
60156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60157       };
60158     } catch (...) {
60159       {
60160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60161       };
60162     }
60163   }
60164
60165   jresult = (int)result;
60166   return jresult;
60167 }
60168
60169 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
60170   int jresult ;
60171   int result;
60172   {
60173     try
60174     {
60175       result = (int)Dali::Toolkit::DevelImageVisual::Property::RELEASE_POLICY;
60176     } catch (std::out_of_range& e) {
60177       {
60178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60179       };
60180     } catch (std::exception& e) {
60181       {
60182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60183       };
60184     } catch (...) {
60185       {
60186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60187       };
60188     }
60189   }
60190   jresult = (int)result;
60191   return jresult;
60192 }
60193
60194 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
60195   int jresult ;
60196   int result;
60197   {
60198     try
60199     {
60200       result = (int)Dali::Toolkit::DevelImageVisual::Property::LOAD_POLICY;
60201     } catch (std::out_of_range& e) {
60202       {
60203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60204       };
60205     } catch (std::exception& e) {
60206       {
60207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60208       };
60209     } catch (...) {
60210       {
60211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60212       };
60213     }
60214   }
60215   jresult = (int)result;
60216   return jresult;
60217 }
60218
60219 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
60220   int jresult ;
60221   int result;
60222   {
60223     try
60224     {
60225       result = (int)Dali::Toolkit::DevelImageVisual::Property::ORIENTATION_CORRECTION;
60226     } catch (std::out_of_range& e) {
60227       {
60228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60229       };
60230     } catch (std::exception& e) {
60231       {
60232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60233       };
60234     } catch (...) {
60235       {
60236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60237       };
60238     }
60239   }
60240   jresult = (int)result;
60241   return jresult;
60242 }
60243
60244
60245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
60246   int jresult ;
60247   int result;
60248   {
60249     try
60250     {
60251       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
60252     } catch (std::out_of_range& e) {
60253       {
60254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60255       };
60256     } catch (std::exception& e) {
60257       {
60258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60259       };
60260     } catch (...) {
60261       {
60262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60263       };
60264     }
60265   }
60266   jresult = (int)result;
60267   return jresult;
60268 }
60269
60270 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
60271   int jresult ;
60272   int result;
60273   {
60274     try
60275     {
60276       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
60277     } catch (std::out_of_range& e) {
60278       {
60279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60280       };
60281     } catch (std::exception& e) {
60282       {
60283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60284       };
60285     } catch (...) {
60286       {
60287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60288       };
60289     }
60290   }
60291   jresult = (int)result;
60292   return jresult;
60293 }
60294
60295
60296
60297 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
60298   int jresult ;
60299   int result;
60300
60301   {
60302     try {
60303       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
60304     } catch (std::out_of_range& e) {
60305       {
60306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60307       };
60308     } catch (std::exception& e) {
60309       {
60310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60311       };
60312     } catch (Dali::DaliException e) {
60313       {
60314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60315       };
60316     } catch (...) {
60317       {
60318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60319       };
60320     }
60321   }
60322
60323   jresult = (int)result;
60324   return jresult;
60325 }
60326
60327
60328 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
60329   int jresult ;
60330   int result;
60331
60332   {
60333     try {
60334       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
60335     } catch (std::out_of_range& e) {
60336       {
60337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60338       };
60339     } catch (std::exception& e) {
60340       {
60341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60342       };
60343     } catch (Dali::DaliException e) {
60344       {
60345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60346       };
60347     } catch (...) {
60348       {
60349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60350       };
60351     }
60352   }
60353
60354   jresult = (int)result;
60355   return jresult;
60356 }
60357
60358
60359 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
60360   int jresult ;
60361   int result;
60362
60363   {
60364     try {
60365       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
60366     } catch (std::out_of_range& e) {
60367       {
60368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60369       };
60370     } catch (std::exception& e) {
60371       {
60372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60373       };
60374     } catch (Dali::DaliException e) {
60375       {
60376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60377       };
60378     } catch (...) {
60379       {
60380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60381       };
60382     }
60383   }
60384
60385   jresult = (int)result;
60386   return jresult;
60387 }
60388
60389
60390 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
60391   int jresult ;
60392   int result;
60393
60394   {
60395     try {
60396       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
60397     } catch (std::out_of_range& e) {
60398       {
60399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60400       };
60401     } catch (std::exception& e) {
60402       {
60403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60404       };
60405     } catch (Dali::DaliException e) {
60406       {
60407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60408       };
60409     } catch (...) {
60410       {
60411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60412       };
60413     }
60414   }
60415
60416   jresult = (int)result;
60417   return jresult;
60418 }
60419
60420
60421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
60422   int jresult ;
60423   int result;
60424
60425   {
60426     try {
60427       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
60428     } catch (std::out_of_range& e) {
60429       {
60430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60431       };
60432     } catch (std::exception& e) {
60433       {
60434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60435       };
60436     } catch (Dali::DaliException e) {
60437       {
60438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60439       };
60440     } catch (...) {
60441       {
60442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60443       };
60444     }
60445   }
60446
60447   jresult = (int)result;
60448   return jresult;
60449 }
60450
60451
60452 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
60453   int jresult ;
60454   int result;
60455
60456   {
60457     try {
60458       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
60459     } catch (std::out_of_range& e) {
60460       {
60461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60462       };
60463     } catch (std::exception& e) {
60464       {
60465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60466       };
60467     } catch (Dali::DaliException e) {
60468       {
60469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60470       };
60471     } catch (...) {
60472       {
60473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60474       };
60475     }
60476   }
60477
60478   jresult = (int)result;
60479   return jresult;
60480 }
60481
60482
60483 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
60484   int jresult ;
60485   int result;
60486
60487   {
60488     try {
60489       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
60490     } catch (std::out_of_range& e) {
60491       {
60492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60493       };
60494     } catch (std::exception& e) {
60495       {
60496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60497       };
60498     } catch (Dali::DaliException e) {
60499       {
60500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60501       };
60502     } catch (...) {
60503       {
60504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60505       };
60506     }
60507   }
60508
60509   jresult = (int)result;
60510   return jresult;
60511 }
60512
60513 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
60514   int jresult ;
60515   int result;
60516
60517   {
60518     try {
60519       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
60520     } catch (std::out_of_range& e) {
60521       {
60522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60523       };
60524     } catch (std::exception& e) {
60525       {
60526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60527       };
60528     } catch (...) {
60529       {
60530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60531       };
60532     }
60533   }
60534   jresult = (int)result;
60535   return jresult;
60536 }
60537
60538 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
60539   int jresult ;
60540   int result;
60541
60542   {
60543     try {
60544       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
60545     } catch (std::out_of_range& e) {
60546       {
60547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60548       };
60549     } catch (std::exception& e) {
60550       {
60551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60552       };
60553     } catch (Dali::DaliException e) {
60554       {
60555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60556       };
60557     } catch (...) {
60558       {
60559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60560       };
60561     }
60562   }
60563
60564   jresult = (int)result;
60565   return jresult;
60566 }
60567
60568
60569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
60570   int jresult ;
60571   int result;
60572
60573   {
60574     try {
60575       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
60576     } catch (std::out_of_range& e) {
60577       {
60578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60579       };
60580     } catch (std::exception& e) {
60581       {
60582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60583       };
60584     } catch (Dali::DaliException e) {
60585       {
60586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60587       };
60588     } catch (...) {
60589       {
60590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60591       };
60592     }
60593   }
60594
60595   jresult = (int)result;
60596   return jresult;
60597 }
60598
60599
60600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
60601   int jresult ;
60602   int result;
60603
60604   {
60605     try {
60606       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
60607     } catch (std::out_of_range& e) {
60608       {
60609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60610       };
60611     } catch (std::exception& e) {
60612       {
60613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60614       };
60615     } catch (Dali::DaliException e) {
60616       {
60617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60618       };
60619     } catch (...) {
60620       {
60621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60622       };
60623     }
60624   }
60625
60626   jresult = (int)result;
60627   return jresult;
60628 }
60629
60630
60631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
60632   int jresult ;
60633   int result;
60634
60635   {
60636     try {
60637       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
60638     } catch (std::out_of_range& e) {
60639       {
60640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60641       };
60642     } catch (std::exception& e) {
60643       {
60644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60645       };
60646     } catch (Dali::DaliException e) {
60647       {
60648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60649       };
60650     } catch (...) {
60651       {
60652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60653       };
60654     }
60655   }
60656
60657   jresult = (int)result;
60658   return jresult;
60659 }
60660
60661
60662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
60663   int jresult ;
60664   int result;
60665
60666   {
60667     try {
60668       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
60669     } catch (std::out_of_range& e) {
60670       {
60671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60672       };
60673     } catch (std::exception& e) {
60674       {
60675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60676       };
60677     } catch (Dali::DaliException e) {
60678       {
60679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60680       };
60681     } catch (...) {
60682       {
60683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60684       };
60685     }
60686   }
60687
60688   jresult = (int)result;
60689   return jresult;
60690 }
60691
60692
60693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
60694   int jresult ;
60695   int result;
60696
60697   {
60698     try {
60699       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
60700     } catch (std::out_of_range& e) {
60701       {
60702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60703       };
60704     } catch (std::exception& e) {
60705       {
60706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60707       };
60708     } catch (Dali::DaliException e) {
60709       {
60710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60711       };
60712     } catch (...) {
60713       {
60714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60715       };
60716     }
60717   }
60718
60719   jresult = (int)result;
60720   return jresult;
60721 }
60722
60723
60724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
60725   int jresult ;
60726   int result;
60727
60728   {
60729     try {
60730       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
60731     } catch (std::out_of_range& e) {
60732       {
60733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60734       };
60735     } catch (std::exception& e) {
60736       {
60737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60738       };
60739     } catch (Dali::DaliException e) {
60740       {
60741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60742       };
60743     } catch (...) {
60744       {
60745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60746       };
60747     }
60748   }
60749
60750   jresult = (int)result;
60751   return jresult;
60752 }
60753
60754
60755 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
60756   int jresult ;
60757   int result;
60758
60759   {
60760     try {
60761       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
60762     } catch (std::out_of_range& e) {
60763       {
60764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60765       };
60766     } catch (std::exception& e) {
60767       {
60768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60769       };
60770     } catch (Dali::DaliException e) {
60771       {
60772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60773       };
60774     } catch (...) {
60775       {
60776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60777       };
60778     }
60779   }
60780
60781   jresult = (int)result;
60782   return jresult;
60783 }
60784
60785
60786 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
60787   int jresult ;
60788   int result;
60789
60790   {
60791     try {
60792       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
60793     } catch (std::out_of_range& e) {
60794       {
60795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60796       };
60797     } catch (std::exception& e) {
60798       {
60799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60800       };
60801     } catch (Dali::DaliException e) {
60802       {
60803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60804       };
60805     } catch (...) {
60806       {
60807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60808       };
60809     }
60810   }
60811
60812   jresult = (int)result;
60813   return jresult;
60814 }
60815
60816
60817 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
60818   int jresult ;
60819   int result;
60820
60821   {
60822     try {
60823       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
60824     } catch (std::out_of_range& e) {
60825       {
60826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60827       };
60828     } catch (std::exception& e) {
60829       {
60830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60831       };
60832     } catch (Dali::DaliException e) {
60833       {
60834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60835       };
60836     } catch (...) {
60837       {
60838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60839       };
60840     }
60841   }
60842
60843   jresult = (int)result;
60844   return jresult;
60845 }
60846
60847
60848 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
60849   int jresult ;
60850   int result;
60851
60852   {
60853     try {
60854       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
60855     } catch (std::out_of_range& e) {
60856       {
60857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60858       };
60859     } catch (std::exception& e) {
60860       {
60861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60862       };
60863     } catch (Dali::DaliException e) {
60864       {
60865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60866       };
60867     } catch (...) {
60868       {
60869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60870       };
60871     }
60872   }
60873
60874   jresult = (int)result;
60875   return jresult;
60876 }
60877
60878
60879 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
60880   int jresult ;
60881   int result;
60882
60883   {
60884     try {
60885       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
60886     } catch (std::out_of_range& e) {
60887       {
60888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60889       };
60890     } catch (std::exception& e) {
60891       {
60892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60893       };
60894     } catch (Dali::DaliException e) {
60895       {
60896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60897       };
60898     } catch (...) {
60899       {
60900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60901       };
60902     }
60903   }
60904
60905   jresult = (int)result;
60906   return jresult;
60907 }
60908
60909
60910 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
60911   int jresult ;
60912   int result;
60913
60914   {
60915     try {
60916       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
60917     } catch (std::out_of_range& e) {
60918       {
60919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60920       };
60921     } catch (std::exception& e) {
60922       {
60923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60924       };
60925     } catch (Dali::DaliException e) {
60926       {
60927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60928       };
60929     } catch (...) {
60930       {
60931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60932       };
60933     }
60934   }
60935
60936   jresult = (int)result;
60937   return jresult;
60938 }
60939
60940
60941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
60942   int jresult ;
60943   int result;
60944
60945   {
60946     try {
60947       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
60948     } catch (std::out_of_range& e) {
60949       {
60950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60951       };
60952     } catch (std::exception& e) {
60953       {
60954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60955       };
60956     } catch (Dali::DaliException e) {
60957       {
60958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60959       };
60960     } catch (...) {
60961       {
60962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60963       };
60964     }
60965   }
60966
60967   jresult = (int)result;
60968   return jresult;
60969 }
60970
60971
60972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
60973   int jresult ;
60974   int result;
60975
60976   {
60977     try {
60978       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
60979     } catch (std::out_of_range& e) {
60980       {
60981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60982       };
60983     } catch (std::exception& e) {
60984       {
60985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60986       };
60987     } catch (Dali::DaliException e) {
60988       {
60989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60990       };
60991     } catch (...) {
60992       {
60993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60994       };
60995     }
60996   }
60997
60998   jresult = (int)result;
60999   return jresult;
61000 }
61001
61002
61003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
61004   int jresult ;
61005   int result;
61006
61007   {
61008     try {
61009       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
61010     } catch (std::out_of_range& e) {
61011       {
61012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61013       };
61014     } catch (std::exception& e) {
61015       {
61016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61017       };
61018     } catch (Dali::DaliException e) {
61019       {
61020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61021       };
61022     } catch (...) {
61023       {
61024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61025       };
61026     }
61027   }
61028
61029   jresult = (int)result;
61030   return jresult;
61031 }
61032
61033
61034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
61035   int jresult ;
61036   int result;
61037
61038   {
61039     try {
61040       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
61041     } catch (std::out_of_range& e) {
61042       {
61043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61044       };
61045     } catch (std::exception& e) {
61046       {
61047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61048       };
61049     } catch (Dali::DaliException e) {
61050       {
61051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61052       };
61053     } catch (...) {
61054       {
61055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61056       };
61057     }
61058   }
61059
61060   jresult = (int)result;
61061   return jresult;
61062 }
61063
61064
61065 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
61066   int jresult ;
61067   int result;
61068
61069   {
61070     try {
61071       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
61072     } catch (std::out_of_range& e) {
61073       {
61074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61075       };
61076     } catch (std::exception& e) {
61077       {
61078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61079       };
61080     } catch (Dali::DaliException e) {
61081       {
61082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61083       };
61084     } catch (...) {
61085       {
61086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61087       };
61088     }
61089   }
61090
61091   jresult = (int)result;
61092   return jresult;
61093 }
61094
61095
61096 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
61097   int jresult ;
61098   int result;
61099
61100   {
61101     try {
61102       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
61103     } catch (std::out_of_range& e) {
61104       {
61105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61106       };
61107     } catch (std::exception& e) {
61108       {
61109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61110       };
61111     } catch (Dali::DaliException e) {
61112       {
61113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61114       };
61115     } catch (...) {
61116       {
61117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61118       };
61119     }
61120   }
61121
61122   jresult = (int)result;
61123   return jresult;
61124 }
61125
61126
61127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
61128   int jresult ;
61129   int result;
61130
61131   {
61132     try {
61133       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
61134     } catch (std::out_of_range& e) {
61135       {
61136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61137       };
61138     } catch (std::exception& e) {
61139       {
61140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61141       };
61142     } catch (Dali::DaliException e) {
61143       {
61144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61145       };
61146     } catch (...) {
61147       {
61148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61149       };
61150     }
61151   }
61152
61153   jresult = (int)result;
61154   return jresult;
61155 }
61156
61157
61158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
61159   int jresult ;
61160   int result;
61161
61162   {
61163     try {
61164       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
61165     } catch (std::out_of_range& e) {
61166       {
61167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61168       };
61169     } catch (std::exception& e) {
61170       {
61171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61172       };
61173     } catch (Dali::DaliException e) {
61174       {
61175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61176       };
61177     } catch (...) {
61178       {
61179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61180       };
61181     }
61182   }
61183
61184   jresult = (int)result;
61185   return jresult;
61186 }
61187
61188
61189 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
61190   int jresult ;
61191   int result;
61192
61193   {
61194     try {
61195       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
61196     } catch (std::out_of_range& e) {
61197       {
61198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61199       };
61200     } catch (std::exception& e) {
61201       {
61202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61203       };
61204     } catch (Dali::DaliException e) {
61205       {
61206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61207       };
61208     } catch (...) {
61209       {
61210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61211       };
61212     }
61213   }
61214
61215   jresult = (int)result;
61216   return jresult;
61217 }
61218
61219
61220 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
61221   int jresult ;
61222   int result;
61223
61224   {
61225     try {
61226       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
61227     } catch (std::out_of_range& e) {
61228       {
61229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61230       };
61231     } catch (std::exception& e) {
61232       {
61233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61234       };
61235     } catch (Dali::DaliException e) {
61236       {
61237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61238       };
61239     } catch (...) {
61240       {
61241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61242       };
61243     }
61244   }
61245
61246   jresult = (int)result;
61247   return jresult;
61248 }
61249
61250
61251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
61252   int jresult ;
61253   int result;
61254
61255   {
61256     try {
61257       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
61258     } catch (std::out_of_range& e) {
61259       {
61260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61261       };
61262     } catch (std::exception& e) {
61263       {
61264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61265       };
61266     } catch (Dali::DaliException e) {
61267       {
61268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61269       };
61270     } catch (...) {
61271       {
61272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61273       };
61274     }
61275   }
61276
61277   jresult = (int)result;
61278   return jresult;
61279 }
61280
61281
61282 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
61283   int jresult ;
61284   int result;
61285
61286   {
61287     try {
61288       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
61289     } catch (std::out_of_range& e) {
61290       {
61291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61292       };
61293     } catch (std::exception& e) {
61294       {
61295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61296       };
61297     } catch (Dali::DaliException e) {
61298       {
61299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61300       };
61301     } catch (...) {
61302       {
61303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61304       };
61305     }
61306   }
61307
61308   jresult = (int)result;
61309   return jresult;
61310 }
61311
61312
61313 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
61314   int jresult ;
61315   int result;
61316
61317   {
61318     try {
61319       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
61320     } catch (std::out_of_range& e) {
61321       {
61322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61323       };
61324     } catch (std::exception& e) {
61325       {
61326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61327       };
61328     } catch (Dali::DaliException e) {
61329       {
61330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61331       };
61332     } catch (...) {
61333       {
61334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61335       };
61336     }
61337   }
61338
61339   jresult = (int)result;
61340   return jresult;
61341 }
61342
61343
61344 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
61345   int jresult ;
61346   int result;
61347
61348   {
61349     try {
61350       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
61351     } catch (std::out_of_range& e) {
61352       {
61353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61354       };
61355     } catch (std::exception& e) {
61356       {
61357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61358       };
61359     } catch (Dali::DaliException e) {
61360       {
61361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61362       };
61363     } catch (...) {
61364       {
61365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61366       };
61367     }
61368   }
61369
61370   jresult = (int)result;
61371   return jresult;
61372 }
61373
61374
61375 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
61376   int jresult ;
61377   int result;
61378
61379   {
61380     try {
61381       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
61382     } catch (std::out_of_range& e) {
61383       {
61384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61385       };
61386     } catch (std::exception& e) {
61387       {
61388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61389       };
61390     } catch (Dali::DaliException e) {
61391       {
61392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61393       };
61394     } catch (...) {
61395       {
61396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61397       };
61398     }
61399   }
61400
61401   jresult = (int)result;
61402   return jresult;
61403 }
61404
61405
61406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
61407   void * jresult ;
61408   Dali::Toolkit::Builder *result = 0 ;
61409
61410   {
61411     try {
61412       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
61413     } catch (std::out_of_range& e) {
61414       {
61415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61416       };
61417     } catch (std::exception& e) {
61418       {
61419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61420       };
61421     } catch (Dali::DaliException e) {
61422       {
61423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61424       };
61425     } catch (...) {
61426       {
61427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61428       };
61429     }
61430   }
61431
61432   jresult = (void *)result;
61433   return jresult;
61434 }
61435
61436
61437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
61438   void * jresult ;
61439   Dali::Toolkit::Builder result;
61440
61441   {
61442     try {
61443       result = Dali::Toolkit::Builder::New();
61444     } catch (std::out_of_range& e) {
61445       {
61446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61447       };
61448     } catch (std::exception& e) {
61449       {
61450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61451       };
61452     } catch (Dali::DaliException e) {
61453       {
61454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61455       };
61456     } catch (...) {
61457       {
61458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61459       };
61460     }
61461   }
61462
61463   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
61464   return jresult;
61465 }
61466
61467
61468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
61469   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61470
61471   arg1 = (Dali::Toolkit::Builder *)jarg1;
61472   {
61473     try {
61474       delete arg1;
61475     } catch (std::out_of_range& e) {
61476       {
61477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61478       };
61479     } catch (std::exception& e) {
61480       {
61481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61482       };
61483     } catch (Dali::DaliException e) {
61484       {
61485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61486       };
61487     } catch (...) {
61488       {
61489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61490       };
61491     }
61492   }
61493
61494 }
61495
61496
61497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
61498   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61499   std::string *arg2 = 0 ;
61500   Dali::Toolkit::Builder::UIFormat arg3 ;
61501
61502   arg1 = (Dali::Toolkit::Builder *)jarg1;
61503   if (!jarg2) {
61504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61505     return ;
61506   }
61507   std::string arg2_str(jarg2);
61508   arg2 = &arg2_str;
61509   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
61510   {
61511     try {
61512       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
61513     } catch (std::out_of_range& e) {
61514       {
61515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61516       };
61517     } catch (std::exception& e) {
61518       {
61519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61520       };
61521     } catch (Dali::DaliException e) {
61522       {
61523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61524       };
61525     } catch (...) {
61526       {
61527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61528       };
61529     }
61530   }
61531
61532
61533   //argout typemap for const std::string&
61534
61535 }
61536
61537
61538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
61539   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61540   std::string *arg2 = 0 ;
61541
61542   arg1 = (Dali::Toolkit::Builder *)jarg1;
61543   if (!jarg2) {
61544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61545     return ;
61546   }
61547   std::string arg2_str(jarg2);
61548   arg2 = &arg2_str;
61549   {
61550     try {
61551       (arg1)->LoadFromString((std::string const &)*arg2);
61552     } catch (std::out_of_range& e) {
61553       {
61554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61555       };
61556     } catch (std::exception& e) {
61557       {
61558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61559       };
61560     } catch (Dali::DaliException e) {
61561       {
61562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61563       };
61564     } catch (...) {
61565       {
61566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61567       };
61568     }
61569   }
61570
61571
61572   //argout typemap for const std::string&
61573
61574 }
61575
61576
61577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
61578   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61579   Dali::Property::Map *arg2 = 0 ;
61580
61581   arg1 = (Dali::Toolkit::Builder *)jarg1;
61582   arg2 = (Dali::Property::Map *)jarg2;
61583   if (!arg2) {
61584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61585     return ;
61586   }
61587   {
61588     try {
61589       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
61590     } catch (std::out_of_range& e) {
61591       {
61592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61593       };
61594     } catch (std::exception& e) {
61595       {
61596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61597       };
61598     } catch (Dali::DaliException e) {
61599       {
61600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61601       };
61602     } catch (...) {
61603       {
61604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61605       };
61606     }
61607   }
61608
61609 }
61610
61611
61612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
61613   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61614   std::string *arg2 = 0 ;
61615   Dali::Property::Value *arg3 = 0 ;
61616
61617   arg1 = (Dali::Toolkit::Builder *)jarg1;
61618   if (!jarg2) {
61619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61620     return ;
61621   }
61622   std::string arg2_str(jarg2);
61623   arg2 = &arg2_str;
61624   arg3 = (Dali::Property::Value *)jarg3;
61625   if (!arg3) {
61626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
61627     return ;
61628   }
61629   {
61630     try {
61631       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
61632     } catch (std::out_of_range& e) {
61633       {
61634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61635       };
61636     } catch (std::exception& e) {
61637       {
61638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61639       };
61640     } catch (Dali::DaliException e) {
61641       {
61642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61643       };
61644     } catch (...) {
61645       {
61646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61647       };
61648     }
61649   }
61650
61651
61652   //argout typemap for const std::string&
61653
61654 }
61655
61656
61657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
61658   void * jresult ;
61659   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61660   Dali::Property::Map *result = 0 ;
61661
61662   arg1 = (Dali::Toolkit::Builder *)jarg1;
61663   {
61664     try {
61665       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
61666     } catch (std::out_of_range& e) {
61667       {
61668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61669       };
61670     } catch (std::exception& e) {
61671       {
61672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61673       };
61674     } catch (Dali::DaliException e) {
61675       {
61676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61677       };
61678     } catch (...) {
61679       {
61680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61681       };
61682     }
61683   }
61684
61685   jresult = (void *)result;
61686   return jresult;
61687 }
61688
61689
61690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
61691   void * jresult ;
61692   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61693   std::string *arg2 = 0 ;
61694   Dali::Property::Value *result = 0 ;
61695
61696   arg1 = (Dali::Toolkit::Builder *)jarg1;
61697   if (!jarg2) {
61698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61699     return 0;
61700   }
61701   std::string arg2_str(jarg2);
61702   arg2 = &arg2_str;
61703   {
61704     try {
61705       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
61706     } catch (std::out_of_range& e) {
61707       {
61708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61709       };
61710     } catch (std::exception& e) {
61711       {
61712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61713       };
61714     } catch (Dali::DaliException e) {
61715       {
61716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61717       };
61718     } catch (...) {
61719       {
61720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61721       };
61722     }
61723   }
61724
61725   jresult = (void *)result;
61726
61727   //argout typemap for const std::string&
61728
61729   return jresult;
61730 }
61731
61732
61733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
61734   void * jresult ;
61735   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61736   std::string *arg2 = 0 ;
61737   Dali::Animation result;
61738
61739   arg1 = (Dali::Toolkit::Builder *)jarg1;
61740   if (!jarg2) {
61741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61742     return 0;
61743   }
61744   std::string arg2_str(jarg2);
61745   arg2 = &arg2_str;
61746   {
61747     try {
61748       result = (arg1)->CreateAnimation((std::string const &)*arg2);
61749     } catch (std::out_of_range& e) {
61750       {
61751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61752       };
61753     } catch (std::exception& e) {
61754       {
61755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61756       };
61757     } catch (Dali::DaliException e) {
61758       {
61759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61760       };
61761     } catch (...) {
61762       {
61763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61764       };
61765     }
61766   }
61767
61768   jresult = new Dali::Animation((const Dali::Animation &)result);
61769
61770   //argout typemap for const std::string&
61771
61772   return jresult;
61773 }
61774
61775
61776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61777   void * jresult ;
61778   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61779   std::string *arg2 = 0 ;
61780   Dali::Property::Map *arg3 = 0 ;
61781   Dali::Animation result;
61782
61783   arg1 = (Dali::Toolkit::Builder *)jarg1;
61784   if (!jarg2) {
61785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61786     return 0;
61787   }
61788   std::string arg2_str(jarg2);
61789   arg2 = &arg2_str;
61790   arg3 = (Dali::Property::Map *)jarg3;
61791   if (!arg3) {
61792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61793     return 0;
61794   }
61795   {
61796     try {
61797       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61798     } catch (std::out_of_range& e) {
61799       {
61800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61801       };
61802     } catch (std::exception& e) {
61803       {
61804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61805       };
61806     } catch (Dali::DaliException e) {
61807       {
61808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61809       };
61810     } catch (...) {
61811       {
61812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61813       };
61814     }
61815   }
61816
61817   jresult = new Dali::Animation((const Dali::Animation &)result);
61818
61819   //argout typemap for const std::string&
61820
61821   return jresult;
61822 }
61823
61824
61825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
61826   void * jresult ;
61827   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61828   std::string *arg2 = 0 ;
61829   Dali::Actor arg3 ;
61830   Dali::Actor *argp3 ;
61831   Dali::Animation result;
61832
61833   arg1 = (Dali::Toolkit::Builder *)jarg1;
61834   if (!jarg2) {
61835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61836     return 0;
61837   }
61838   std::string arg2_str(jarg2);
61839   arg2 = &arg2_str;
61840   argp3 = (Dali::Actor *)jarg3;
61841   if (!argp3) {
61842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61843     return 0;
61844   }
61845   arg3 = *argp3;
61846   {
61847     try {
61848       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
61849     } catch (std::out_of_range& e) {
61850       {
61851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61852       };
61853     } catch (std::exception& e) {
61854       {
61855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61856       };
61857     } catch (Dali::DaliException e) {
61858       {
61859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61860       };
61861     } catch (...) {
61862       {
61863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61864       };
61865     }
61866   }
61867
61868   jresult = new Dali::Animation((const Dali::Animation &)result);
61869
61870   //argout typemap for const std::string&
61871
61872   return jresult;
61873 }
61874
61875
61876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
61877   void * jresult ;
61878   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61879   std::string *arg2 = 0 ;
61880   Dali::Property::Map *arg3 = 0 ;
61881   Dali::Actor arg4 ;
61882   Dali::Actor *argp4 ;
61883   Dali::Animation result;
61884
61885   arg1 = (Dali::Toolkit::Builder *)jarg1;
61886   if (!jarg2) {
61887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61888     return 0;
61889   }
61890   std::string arg2_str(jarg2);
61891   arg2 = &arg2_str;
61892   arg3 = (Dali::Property::Map *)jarg3;
61893   if (!arg3) {
61894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61895     return 0;
61896   }
61897   argp4 = (Dali::Actor *)jarg4;
61898   if (!argp4) {
61899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61900     return 0;
61901   }
61902   arg4 = *argp4;
61903   {
61904     try {
61905       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
61906     } catch (std::out_of_range& e) {
61907       {
61908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61909       };
61910     } catch (std::exception& e) {
61911       {
61912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61913       };
61914     } catch (Dali::DaliException e) {
61915       {
61916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61917       };
61918     } catch (...) {
61919       {
61920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61921       };
61922     }
61923   }
61924
61925   jresult = new Dali::Animation((const Dali::Animation &)result);
61926
61927   //argout typemap for const std::string&
61928
61929   return jresult;
61930 }
61931
61932
61933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
61934   void * jresult ;
61935   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61936   std::string *arg2 = 0 ;
61937   Dali::BaseHandle result;
61938
61939   arg1 = (Dali::Toolkit::Builder *)jarg1;
61940   if (!jarg2) {
61941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61942     return 0;
61943   }
61944   std::string arg2_str(jarg2);
61945   arg2 = &arg2_str;
61946   {
61947     try {
61948       result = (arg1)->Create((std::string const &)*arg2);
61949     } catch (std::out_of_range& e) {
61950       {
61951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61952       };
61953     } catch (std::exception& e) {
61954       {
61955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61956       };
61957     } catch (Dali::DaliException e) {
61958       {
61959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61960       };
61961     } catch (...) {
61962       {
61963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61964       };
61965     }
61966   }
61967
61968   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61969
61970   //argout typemap for const std::string&
61971
61972   return jresult;
61973 }
61974
61975
61976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61977   void * jresult ;
61978   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61979   std::string *arg2 = 0 ;
61980   Dali::Property::Map *arg3 = 0 ;
61981   Dali::BaseHandle result;
61982
61983   arg1 = (Dali::Toolkit::Builder *)jarg1;
61984   if (!jarg2) {
61985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61986     return 0;
61987   }
61988   std::string arg2_str(jarg2);
61989   arg2 = &arg2_str;
61990   arg3 = (Dali::Property::Map *)jarg3;
61991   if (!arg3) {
61992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61993     return 0;
61994   }
61995   {
61996     try {
61997       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61998     } catch (std::out_of_range& e) {
61999       {
62000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62001       };
62002     } catch (std::exception& e) {
62003       {
62004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62005       };
62006     } catch (Dali::DaliException e) {
62007       {
62008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62009       };
62010     } catch (...) {
62011       {
62012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62013       };
62014     }
62015   }
62016
62017   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
62018
62019   //argout typemap for const std::string&
62020
62021   return jresult;
62022 }
62023
62024
62025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
62026   void * jresult ;
62027   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62028   std::string *arg2 = 0 ;
62029   Dali::BaseHandle result;
62030
62031   arg1 = (Dali::Toolkit::Builder *)jarg1;
62032   if (!jarg2) {
62033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62034     return 0;
62035   }
62036   std::string arg2_str(jarg2);
62037   arg2 = &arg2_str;
62038   {
62039     try {
62040       result = (arg1)->CreateFromJson((std::string const &)*arg2);
62041     } catch (std::out_of_range& e) {
62042       {
62043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62044       };
62045     } catch (std::exception& e) {
62046       {
62047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62048       };
62049     } catch (Dali::DaliException e) {
62050       {
62051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62052       };
62053     } catch (...) {
62054       {
62055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62056       };
62057     }
62058   }
62059
62060   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
62061
62062   //argout typemap for const std::string&
62063
62064   return jresult;
62065 }
62066
62067
62068 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
62069   unsigned int jresult ;
62070   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62071   std::string *arg2 = 0 ;
62072   Dali::Handle *arg3 = 0 ;
62073   bool result;
62074
62075   arg1 = (Dali::Toolkit::Builder *)jarg1;
62076   if (!jarg2) {
62077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62078     return 0;
62079   }
62080   std::string arg2_str(jarg2);
62081   arg2 = &arg2_str;
62082   arg3 = (Dali::Handle *)jarg3;
62083   if (!arg3) {
62084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
62085     return 0;
62086   }
62087   {
62088     try {
62089       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
62090     } catch (std::out_of_range& e) {
62091       {
62092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62093       };
62094     } catch (std::exception& e) {
62095       {
62096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62097       };
62098     } catch (Dali::DaliException e) {
62099       {
62100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62101       };
62102     } catch (...) {
62103       {
62104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62105       };
62106     }
62107   }
62108
62109   jresult = result;
62110
62111   //argout typemap for const std::string&
62112
62113   return jresult;
62114 }
62115
62116
62117 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
62118   unsigned int jresult ;
62119   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62120   Dali::Handle *arg2 = 0 ;
62121   std::string *arg3 = 0 ;
62122   bool result;
62123
62124   arg1 = (Dali::Toolkit::Builder *)jarg1;
62125   arg2 = (Dali::Handle *)jarg2;
62126   if (!arg2) {
62127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
62128     return 0;
62129   }
62130   if (!jarg3) {
62131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62132     return 0;
62133   }
62134   std::string arg3_str(jarg3);
62135   arg3 = &arg3_str;
62136   {
62137     try {
62138       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
62139     } catch (std::out_of_range& e) {
62140       {
62141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62142       };
62143     } catch (std::exception& e) {
62144       {
62145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62146       };
62147     } catch (Dali::DaliException e) {
62148       {
62149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62150       };
62151     } catch (...) {
62152       {
62153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62154       };
62155     }
62156   }
62157
62158   jresult = result;
62159
62160   //argout typemap for const std::string&
62161
62162   return jresult;
62163 }
62164
62165
62166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
62167   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62168   Dali::Actor arg2 ;
62169   Dali::Actor *argp2 ;
62170
62171   arg1 = (Dali::Toolkit::Builder *)jarg1;
62172   argp2 = (Dali::Actor *)jarg2;
62173   if (!argp2) {
62174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62175     return ;
62176   }
62177   arg2 = *argp2;
62178   {
62179     try {
62180       (arg1)->AddActors(arg2);
62181     } catch (std::out_of_range& e) {
62182       {
62183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62184       };
62185     } catch (std::exception& e) {
62186       {
62187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62188       };
62189     } catch (Dali::DaliException e) {
62190       {
62191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62192       };
62193     } catch (...) {
62194       {
62195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62196       };
62197     }
62198   }
62199
62200 }
62201
62202
62203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
62204   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62205   std::string *arg2 = 0 ;
62206   Dali::Actor arg3 ;
62207   Dali::Actor *argp3 ;
62208
62209   arg1 = (Dali::Toolkit::Builder *)jarg1;
62210   if (!jarg2) {
62211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62212     return ;
62213   }
62214   std::string arg2_str(jarg2);
62215   arg2 = &arg2_str;
62216   argp3 = (Dali::Actor *)jarg3;
62217   if (!argp3) {
62218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62219     return ;
62220   }
62221   arg3 = *argp3;
62222   {
62223     try {
62224       (arg1)->AddActors((std::string const &)*arg2,arg3);
62225     } catch (std::out_of_range& e) {
62226       {
62227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62228       };
62229     } catch (std::exception& e) {
62230       {
62231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62232       };
62233     } catch (Dali::DaliException e) {
62234       {
62235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62236       };
62237     } catch (...) {
62238       {
62239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62240       };
62241     }
62242   }
62243
62244
62245   //argout typemap for const std::string&
62246
62247 }
62248
62249
62250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
62251   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62252   std::string *arg2 = 0 ;
62253
62254   arg1 = (Dali::Toolkit::Builder *)jarg1;
62255   if (!jarg2) {
62256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62257     return ;
62258   }
62259   std::string arg2_str(jarg2);
62260   arg2 = &arg2_str;
62261   {
62262     try {
62263       (arg1)->CreateRenderTask((std::string const &)*arg2);
62264     } catch (std::out_of_range& e) {
62265       {
62266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62267       };
62268     } catch (std::exception& e) {
62269       {
62270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62271       };
62272     } catch (Dali::DaliException e) {
62273       {
62274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62275       };
62276     } catch (...) {
62277       {
62278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62279       };
62280     }
62281   }
62282
62283
62284   //argout typemap for const std::string&
62285
62286 }
62287
62288
62289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
62290   void * jresult ;
62291   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62292   std::string *arg2 = 0 ;
62293   Dali::FrameBufferImage result;
62294
62295   arg1 = (Dali::Toolkit::Builder *)jarg1;
62296   if (!jarg2) {
62297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62298     return 0;
62299   }
62300   std::string arg2_str(jarg2);
62301   arg2 = &arg2_str;
62302   {
62303     try {
62304       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
62305     } catch (std::out_of_range& e) {
62306       {
62307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62308       };
62309     } catch (std::exception& e) {
62310       {
62311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62312       };
62313     } catch (Dali::DaliException e) {
62314       {
62315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62316       };
62317     } catch (...) {
62318       {
62319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62320       };
62321     }
62322   }
62323
62324   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
62325
62326   //argout typemap for const std::string&
62327
62328   return jresult;
62329 }
62330
62331
62332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
62333   void * jresult ;
62334   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62335   std::string *arg2 = 0 ;
62336   Dali::Path result;
62337
62338   arg1 = (Dali::Toolkit::Builder *)jarg1;
62339   if (!jarg2) {
62340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62341     return 0;
62342   }
62343   std::string arg2_str(jarg2);
62344   arg2 = &arg2_str;
62345   {
62346     try {
62347       result = (arg1)->GetPath((std::string const &)*arg2);
62348     } catch (std::out_of_range& e) {
62349       {
62350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62351       };
62352     } catch (std::exception& e) {
62353       {
62354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62355       };
62356     } catch (Dali::DaliException e) {
62357       {
62358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62359       };
62360     } catch (...) {
62361       {
62362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62363       };
62364     }
62365   }
62366
62367   jresult = new Dali::Path((const Dali::Path &)result);
62368
62369   //argout typemap for const std::string&
62370
62371   return jresult;
62372 }
62373
62374
62375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
62376   void * jresult ;
62377   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62378   std::string *arg2 = 0 ;
62379   Dali::PathConstrainer result;
62380
62381   arg1 = (Dali::Toolkit::Builder *)jarg1;
62382   if (!jarg2) {
62383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62384     return 0;
62385   }
62386   std::string arg2_str(jarg2);
62387   arg2 = &arg2_str;
62388   {
62389     try {
62390       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
62391     } catch (std::out_of_range& e) {
62392       {
62393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62394       };
62395     } catch (std::exception& e) {
62396       {
62397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62398       };
62399     } catch (Dali::DaliException e) {
62400       {
62401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62402       };
62403     } catch (...) {
62404       {
62405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62406       };
62407     }
62408   }
62409
62410   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
62411
62412   //argout typemap for const std::string&
62413
62414   return jresult;
62415 }
62416
62417
62418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
62419   void * jresult ;
62420   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62421   std::string *arg2 = 0 ;
62422   Dali::LinearConstrainer result;
62423
62424   arg1 = (Dali::Toolkit::Builder *)jarg1;
62425   if (!jarg2) {
62426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62427     return 0;
62428   }
62429   std::string arg2_str(jarg2);
62430   arg2 = &arg2_str;
62431   {
62432     try {
62433       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
62434     } catch (std::out_of_range& e) {
62435       {
62436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62437       };
62438     } catch (std::exception& e) {
62439       {
62440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62441       };
62442     } catch (Dali::DaliException e) {
62443       {
62444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62445       };
62446     } catch (...) {
62447       {
62448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62449       };
62450     }
62451   }
62452
62453   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
62454
62455   //argout typemap for const std::string&
62456
62457   return jresult;
62458 }
62459
62460
62461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
62462   void * jresult ;
62463   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62464   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
62465
62466   arg1 = (Dali::Toolkit::Builder *)jarg1;
62467   {
62468     try {
62469       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
62470     } catch (std::out_of_range& e) {
62471       {
62472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62473       };
62474     } catch (std::exception& e) {
62475       {
62476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62477       };
62478     } catch (Dali::DaliException e) {
62479       {
62480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62481       };
62482     } catch (...) {
62483       {
62484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62485       };
62486     }
62487   }
62488
62489   jresult = (void *)result;
62490   return jresult;
62491 }
62492
62493
62494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
62495   void * jresult ;
62496   Dali::Toolkit::TransitionData *result = 0 ;
62497
62498   {
62499     try {
62500       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
62501     } catch (std::out_of_range& e) {
62502       {
62503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62504       };
62505     } catch (std::exception& e) {
62506       {
62507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62508       };
62509     } catch (Dali::DaliException e) {
62510       {
62511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62512       };
62513     } catch (...) {
62514       {
62515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62516       };
62517     }
62518   }
62519
62520   jresult = (void *)result;
62521   return jresult;
62522 }
62523
62524
62525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
62526   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62527
62528   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62529   {
62530     try {
62531       delete arg1;
62532     } catch (std::out_of_range& e) {
62533       {
62534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62535       };
62536     } catch (std::exception& e) {
62537       {
62538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62539       };
62540     } catch (Dali::DaliException e) {
62541       {
62542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62543       };
62544     } catch (...) {
62545       {
62546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62547       };
62548     }
62549   }
62550
62551 }
62552
62553
62554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
62555   void * jresult ;
62556   Dali::Property::Map *arg1 = 0 ;
62557   Dali::Toolkit::TransitionData result;
62558
62559   arg1 = (Dali::Property::Map *)jarg1;
62560   if (!arg1) {
62561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62562     return 0;
62563   }
62564   {
62565     try {
62566       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
62567     } catch (std::out_of_range& e) {
62568       {
62569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62570       };
62571     } catch (std::exception& e) {
62572       {
62573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62574       };
62575     } catch (Dali::DaliException e) {
62576       {
62577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62578       };
62579     } catch (...) {
62580       {
62581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62582       };
62583     }
62584   }
62585
62586   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62587   return jresult;
62588 }
62589
62590
62591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
62592   void * jresult ;
62593   Dali::Property::Array *arg1 = 0 ;
62594   Dali::Toolkit::TransitionData result;
62595
62596   arg1 = (Dali::Property::Array *)jarg1;
62597   if (!arg1) {
62598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
62599     return 0;
62600   }
62601   {
62602     try {
62603       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
62604     } catch (std::out_of_range& e) {
62605       {
62606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62607       };
62608     } catch (std::exception& e) {
62609       {
62610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62611       };
62612     } catch (Dali::DaliException e) {
62613       {
62614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62615       };
62616     } catch (...) {
62617       {
62618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62619       };
62620     }
62621   }
62622
62623   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62624   return jresult;
62625 }
62626
62627
62628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
62629   void * jresult ;
62630   Dali::BaseHandle arg1 ;
62631   Dali::BaseHandle *argp1 ;
62632   Dali::Toolkit::TransitionData result;
62633
62634   argp1 = (Dali::BaseHandle *)jarg1;
62635   if (!argp1) {
62636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62637     return 0;
62638   }
62639   arg1 = *argp1;
62640   {
62641     try {
62642       result = Dali::Toolkit::TransitionData::DownCast(arg1);
62643     } catch (std::out_of_range& e) {
62644       {
62645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62646       };
62647     } catch (std::exception& e) {
62648       {
62649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62650       };
62651     } catch (Dali::DaliException e) {
62652       {
62653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62654       };
62655     } catch (...) {
62656       {
62657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62658       };
62659     }
62660   }
62661
62662   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62663   return jresult;
62664 }
62665
62666
62667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
62668   void * jresult ;
62669   Dali::Toolkit::TransitionData *arg1 = 0 ;
62670   Dali::Toolkit::TransitionData *result = 0 ;
62671
62672   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62673   if (!arg1) {
62674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62675     return 0;
62676   }
62677   {
62678     try {
62679       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
62680     } catch (std::out_of_range& e) {
62681       {
62682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62683       };
62684     } catch (std::exception& e) {
62685       {
62686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62687       };
62688     } catch (Dali::DaliException e) {
62689       {
62690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62691       };
62692     } catch (...) {
62693       {
62694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62695       };
62696     }
62697   }
62698
62699   jresult = (void *)result;
62700   return jresult;
62701 }
62702
62703
62704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
62705   void * jresult ;
62706   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62707   Dali::Toolkit::TransitionData *arg2 = 0 ;
62708   Dali::Toolkit::TransitionData *result = 0 ;
62709
62710   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62711   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
62712   if (!arg2) {
62713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62714     return 0;
62715   }
62716   {
62717     try {
62718       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
62719     } catch (std::out_of_range& e) {
62720       {
62721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62722       };
62723     } catch (std::exception& e) {
62724       {
62725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62726       };
62727     } catch (Dali::DaliException e) {
62728       {
62729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62730       };
62731     } catch (...) {
62732       {
62733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62734       };
62735     }
62736   }
62737
62738   jresult = (void *)result;
62739   return jresult;
62740 }
62741
62742
62743 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
62744   unsigned long jresult ;
62745   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62746   size_t result;
62747
62748   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62749   {
62750     try {
62751       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
62752     } catch (std::out_of_range& e) {
62753       {
62754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62755       };
62756     } catch (std::exception& e) {
62757       {
62758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62759       };
62760     } catch (Dali::DaliException e) {
62761       {
62762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62763       };
62764     } catch (...) {
62765       {
62766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62767       };
62768     }
62769   }
62770
62771   jresult = (unsigned long)result;
62772   return jresult;
62773 }
62774
62775
62776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
62777   void * jresult ;
62778   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62779   size_t arg2 ;
62780   Dali::Property::Map result;
62781
62782   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62783   arg2 = (size_t)jarg2;
62784   {
62785     try {
62786       result = (arg1)->GetAnimatorAt(arg2);
62787     } catch (std::out_of_range& e) {
62788       {
62789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62790       };
62791     } catch (std::exception& e) {
62792       {
62793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62794       };
62795     } catch (Dali::DaliException e) {
62796       {
62797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62798       };
62799     } catch (...) {
62800       {
62801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62802       };
62803     }
62804   }
62805
62806   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
62807   return jresult;
62808 }
62809
62810
62811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_2(void * jarg1) {
62812   void * jresult ;
62813   Dali::Toolkit::Internal::TransitionData *arg1 = (Dali::Toolkit::Internal::TransitionData *) 0 ;
62814   Dali::Toolkit::TransitionData *result = 0 ;
62815
62816   arg1 = (Dali::Toolkit::Internal::TransitionData *)jarg1;
62817   {
62818     try {
62819       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData(arg1);
62820     } catch (std::out_of_range& e) {
62821       {
62822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62823       };
62824     } catch (std::exception& e) {
62825       {
62826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62827       };
62828     } catch (Dali::DaliException e) {
62829       {
62830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62831       };
62832     } catch (...) {
62833       {
62834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62835       };
62836     }
62837   }
62838
62839   jresult = (void *)result;
62840   return jresult;
62841 }
62842
62843
62844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
62845   int jresult ;
62846   int result;
62847
62848   {
62849     try {
62850       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
62851     } catch (std::out_of_range& e) {
62852       {
62853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62854       };
62855     } catch (std::exception& e) {
62856       {
62857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62858       };
62859     } catch (Dali::DaliException e) {
62860       {
62861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62862       };
62863     } catch (...) {
62864       {
62865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62866       };
62867     }
62868   }
62869
62870   jresult = (int)result;
62871   return jresult;
62872 }
62873
62874
62875 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
62876   int jresult ;
62877   int result;
62878
62879   {
62880     try {
62881       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
62882     } catch (std::out_of_range& e) {
62883       {
62884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62885       };
62886     } catch (std::exception& e) {
62887       {
62888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62889       };
62890     } catch (Dali::DaliException e) {
62891       {
62892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62893       };
62894     } catch (...) {
62895       {
62896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62897       };
62898     }
62899   }
62900
62901   jresult = (int)result;
62902   return jresult;
62903 }
62904
62905
62906 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
62907   int jresult ;
62908   int result;
62909
62910   {
62911     try {
62912       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
62913     } catch (std::out_of_range& e) {
62914       {
62915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62916       };
62917     } catch (std::exception& e) {
62918       {
62919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62920       };
62921     } catch (Dali::DaliException e) {
62922       {
62923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62924       };
62925     } catch (...) {
62926       {
62927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62928       };
62929     }
62930   }
62931
62932   jresult = (int)result;
62933   return jresult;
62934 }
62935
62936
62937 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
62938   int jresult ;
62939   int result;
62940
62941   {
62942     try {
62943       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
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 = (int)result;
62964   return jresult;
62965 }
62966
62967
62968 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
62969   int jresult ;
62970   int result;
62971
62972   {
62973     try {
62974       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
62975     } catch (std::out_of_range& e) {
62976       {
62977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62978       };
62979     } catch (std::exception& e) {
62980       {
62981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62982       };
62983     } catch (Dali::DaliException e) {
62984       {
62985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62986       };
62987     } catch (...) {
62988       {
62989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62990       };
62991     }
62992   }
62993
62994   jresult = (int)result;
62995   return jresult;
62996 }
62997
62998
62999 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
63000   int jresult ;
63001   int result;
63002
63003   {
63004     try {
63005       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
63006     } catch (std::out_of_range& e) {
63007       {
63008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63009       };
63010     } catch (std::exception& e) {
63011       {
63012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63013       };
63014     } catch (Dali::DaliException e) {
63015       {
63016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63017       };
63018     } catch (...) {
63019       {
63020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63021       };
63022     }
63023   }
63024
63025   jresult = (int)result;
63026   return jresult;
63027 }
63028
63029
63030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
63031   int jresult ;
63032   int result;
63033
63034   {
63035     try {
63036       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
63037     } catch (std::out_of_range& e) {
63038       {
63039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63040       };
63041     } catch (std::exception& e) {
63042       {
63043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63044       };
63045     } catch (Dali::DaliException e) {
63046       {
63047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63048       };
63049     } catch (...) {
63050       {
63051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63052       };
63053     }
63054   }
63055
63056   jresult = (int)result;
63057   return jresult;
63058 }
63059
63060
63061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
63062   int jresult ;
63063   int result;
63064
63065   {
63066     try {
63067       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
63068     } catch (std::out_of_range& e) {
63069       {
63070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63071       };
63072     } catch (std::exception& e) {
63073       {
63074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63075       };
63076     } catch (Dali::DaliException e) {
63077       {
63078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63079       };
63080     } catch (...) {
63081       {
63082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63083       };
63084     }
63085   }
63086
63087   jresult = (int)result;
63088   return jresult;
63089 }
63090
63091
63092 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
63093   int jresult ;
63094   int result;
63095
63096   {
63097     try {
63098       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
63099     } catch (std::out_of_range& e) {
63100       {
63101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63102       };
63103     } catch (std::exception& e) {
63104       {
63105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63106       };
63107     } catch (Dali::DaliException e) {
63108       {
63109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63110       };
63111     } catch (...) {
63112       {
63113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63114       };
63115     }
63116   }
63117
63118   jresult = (int)result;
63119   return jresult;
63120 }
63121
63122
63123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
63124   int jresult ;
63125   int result;
63126
63127   {
63128     try {
63129       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
63130     } catch (std::out_of_range& e) {
63131       {
63132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63133       };
63134     } catch (std::exception& e) {
63135       {
63136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63137       };
63138     } catch (Dali::DaliException e) {
63139       {
63140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63141       };
63142     } catch (...) {
63143       {
63144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63145       };
63146     }
63147   }
63148
63149   jresult = (int)result;
63150   return jresult;
63151 }
63152
63153
63154 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
63155   int jresult ;
63156   int result;
63157
63158   {
63159     try {
63160       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
63161     } catch (std::out_of_range& e) {
63162       {
63163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63164       };
63165     } catch (std::exception& e) {
63166       {
63167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63168       };
63169     } catch (Dali::DaliException e) {
63170       {
63171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63172       };
63173     } catch (...) {
63174       {
63175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63176       };
63177     }
63178   }
63179
63180   jresult = (int)result;
63181   return jresult;
63182 }
63183
63184
63185 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
63186   int jresult ;
63187   int result;
63188
63189   {
63190     try {
63191       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
63192     } catch (std::out_of_range& e) {
63193       {
63194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63195       };
63196     } catch (std::exception& e) {
63197       {
63198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63199       };
63200     } catch (Dali::DaliException e) {
63201       {
63202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63203       };
63204     } catch (...) {
63205       {
63206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63207       };
63208     }
63209   }
63210
63211   jresult = (int)result;
63212   return jresult;
63213 }
63214
63215
63216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
63217   int jresult ;
63218   int result;
63219
63220   {
63221     try {
63222       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
63223     } catch (std::out_of_range& e) {
63224       {
63225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63226       };
63227     } catch (std::exception& e) {
63228       {
63229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63230       };
63231     } catch (Dali::DaliException e) {
63232       {
63233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63234       };
63235     } catch (...) {
63236       {
63237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63238       };
63239     }
63240   }
63241
63242   jresult = (int)result;
63243   return jresult;
63244 }
63245
63246
63247 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
63248   int jresult ;
63249   int result;
63250
63251   {
63252     try {
63253       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
63254     } catch (std::out_of_range& e) {
63255       {
63256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63257       };
63258     } catch (std::exception& e) {
63259       {
63260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63261       };
63262     } catch (Dali::DaliException e) {
63263       {
63264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63265       };
63266     } catch (...) {
63267       {
63268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63269       };
63270     }
63271   }
63272
63273   jresult = (int)result;
63274   return jresult;
63275 }
63276
63277
63278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
63279   void * jresult ;
63280   Dali::Toolkit::Control result;
63281
63282   {
63283     try {
63284       result = Dali::Toolkit::Internal::Control::New();
63285     } catch (std::out_of_range& e) {
63286       {
63287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63288       };
63289     } catch (std::exception& e) {
63290       {
63291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63292       };
63293     } catch (Dali::DaliException e) {
63294       {
63295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63296       };
63297     } catch (...) {
63298       {
63299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63300       };
63301     }
63302   }
63303
63304   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63305   return jresult;
63306 }
63307
63308
63309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
63310   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63311   std::string *arg2 = 0 ;
63312
63313   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63314   if (!jarg2) {
63315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63316     return ;
63317   }
63318   std::string arg2_str(jarg2);
63319   arg2 = &arg2_str;
63320   {
63321     try {
63322       (arg1)->SetStyleName((std::string const &)*arg2);
63323     } catch (std::out_of_range& e) {
63324       {
63325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63326       };
63327     } catch (std::exception& e) {
63328       {
63329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63330       };
63331     } catch (Dali::DaliException e) {
63332       {
63333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63334       };
63335     } catch (...) {
63336       {
63337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63338       };
63339     }
63340   }
63341
63342
63343   //argout typemap for const std::string&
63344
63345 }
63346
63347
63348 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
63349   char * jresult ;
63350   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63351   std::string *result = 0 ;
63352
63353   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63354   {
63355     try {
63356       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
63357     } catch (std::out_of_range& e) {
63358       {
63359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63360       };
63361     } catch (std::exception& e) {
63362       {
63363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63364       };
63365     } catch (Dali::DaliException e) {
63366       {
63367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63368       };
63369     } catch (...) {
63370       {
63371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63372       };
63373     }
63374   }
63375
63376   jresult = SWIG_csharp_string_callback(result->c_str());
63377   return jresult;
63378 }
63379
63380
63381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
63382   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63383   Dali::Vector4 *arg2 = 0 ;
63384
63385   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63386   arg2 = (Dali::Vector4 *)jarg2;
63387   if (!arg2) {
63388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63389     return ;
63390   }
63391   {
63392     try {
63393       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63394     } catch (std::out_of_range& e) {
63395       {
63396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63397       };
63398     } catch (std::exception& e) {
63399       {
63400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63401       };
63402     } catch (Dali::DaliException e) {
63403       {
63404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63405       };
63406     } catch (...) {
63407       {
63408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63409       };
63410     }
63411   }
63412
63413 }
63414
63415
63416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
63417   void * jresult ;
63418   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63419   Dali::Vector4 result;
63420
63421   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63422   {
63423     try {
63424       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
63425     } catch (std::out_of_range& e) {
63426       {
63427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63428       };
63429     } catch (std::exception& e) {
63430       {
63431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63432       };
63433     } catch (Dali::DaliException e) {
63434       {
63435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63436       };
63437     } catch (...) {
63438       {
63439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63440       };
63441     }
63442   }
63443
63444   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
63445   return jresult;
63446 }
63447
63448
63449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
63450   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63451   Dali::Image arg2 ;
63452   Dali::Image *argp2 ;
63453
63454   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63455   argp2 = (Dali::Image *)jarg2;
63456   if (!argp2) {
63457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
63458     return ;
63459   }
63460   arg2 = *argp2;
63461   {
63462     try {
63463       (arg1)->SetBackgroundImage(arg2);
63464     } catch (std::out_of_range& e) {
63465       {
63466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63467       };
63468     } catch (std::exception& e) {
63469       {
63470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63471       };
63472     } catch (Dali::DaliException e) {
63473       {
63474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63475       };
63476     } catch (...) {
63477       {
63478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63479       };
63480     }
63481   }
63482
63483 }
63484
63485
63486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
63487   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63488   Dali::Property::Map *arg2 = 0 ;
63489
63490   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63491   arg2 = (Dali::Property::Map *)jarg2;
63492   if (!arg2) {
63493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
63494     return ;
63495   }
63496   {
63497     try {
63498       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
63499     } catch (std::out_of_range& e) {
63500       {
63501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63502       };
63503     } catch (std::exception& e) {
63504       {
63505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63506       };
63507     } catch (Dali::DaliException e) {
63508       {
63509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63510       };
63511     } catch (...) {
63512       {
63513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63514       };
63515     }
63516   }
63517
63518 }
63519
63520
63521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
63522   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63523
63524   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63525   {
63526     try {
63527       (arg1)->ClearBackground();
63528     } catch (std::out_of_range& e) {
63529       {
63530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63531       };
63532     } catch (std::exception& e) {
63533       {
63534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63535       };
63536     } catch (Dali::DaliException e) {
63537       {
63538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63539       };
63540     } catch (...) {
63541       {
63542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63543       };
63544     }
63545   }
63546
63547 }
63548
63549
63550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
63551   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63552   Dali::Gesture::Type arg2 ;
63553
63554   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63555   arg2 = (Dali::Gesture::Type)jarg2;
63556   {
63557     try {
63558       (arg1)->EnableGestureDetection(arg2);
63559     } catch (std::out_of_range& e) {
63560       {
63561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63562       };
63563     } catch (std::exception& e) {
63564       {
63565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63566       };
63567     } catch (Dali::DaliException e) {
63568       {
63569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63570       };
63571     } catch (...) {
63572       {
63573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63574       };
63575     }
63576   }
63577
63578 }
63579
63580
63581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
63582   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63583   Dali::Gesture::Type arg2 ;
63584
63585   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63586   arg2 = (Dali::Gesture::Type)jarg2;
63587   {
63588     try {
63589       (arg1)->DisableGestureDetection(arg2);
63590     } catch (std::out_of_range& e) {
63591       {
63592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63593       };
63594     } catch (std::exception& e) {
63595       {
63596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63597       };
63598     } catch (Dali::DaliException e) {
63599       {
63600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63601       };
63602     } catch (...) {
63603       {
63604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63605       };
63606     }
63607   }
63608
63609 }
63610
63611
63612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
63613   void * jresult ;
63614   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63615   Dali::PinchGestureDetector result;
63616
63617   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63618   {
63619     try {
63620       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
63621     } catch (std::out_of_range& e) {
63622       {
63623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63624       };
63625     } catch (std::exception& e) {
63626       {
63627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63628       };
63629     } catch (Dali::DaliException e) {
63630       {
63631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63632       };
63633     } catch (...) {
63634       {
63635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63636       };
63637     }
63638   }
63639
63640   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63641   return jresult;
63642 }
63643
63644
63645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
63646   void * jresult ;
63647   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63648   Dali::PanGestureDetector result;
63649
63650   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63651   {
63652     try {
63653       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
63654     } catch (std::out_of_range& e) {
63655       {
63656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63657       };
63658     } catch (std::exception& e) {
63659       {
63660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63661       };
63662     } catch (Dali::DaliException e) {
63663       {
63664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63665       };
63666     } catch (...) {
63667       {
63668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63669       };
63670     }
63671   }
63672
63673   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63674   return jresult;
63675 }
63676
63677
63678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
63679   void * jresult ;
63680   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63681   Dali::TapGestureDetector result;
63682
63683   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63684   {
63685     try {
63686       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
63687     } catch (std::out_of_range& e) {
63688       {
63689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63690       };
63691     } catch (std::exception& e) {
63692       {
63693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63694       };
63695     } catch (Dali::DaliException e) {
63696       {
63697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63698       };
63699     } catch (...) {
63700       {
63701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63702       };
63703     }
63704   }
63705
63706   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63707   return jresult;
63708 }
63709
63710
63711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
63712   void * jresult ;
63713   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63714   Dali::LongPressGestureDetector result;
63715
63716   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63717   {
63718     try {
63719       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
63720     } catch (std::out_of_range& e) {
63721       {
63722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63723       };
63724     } catch (std::exception& e) {
63725       {
63726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63727       };
63728     } catch (Dali::DaliException e) {
63729       {
63730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63731       };
63732     } catch (...) {
63733       {
63734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63735       };
63736     }
63737   }
63738
63739   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63740   return jresult;
63741 }
63742
63743
63744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
63745   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63746   bool arg2 ;
63747
63748   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63749   arg2 = jarg2 ? true : false;
63750   {
63751     try {
63752       (arg1)->SetKeyboardNavigationSupport(arg2);
63753     } catch (std::out_of_range& e) {
63754       {
63755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63756       };
63757     } catch (std::exception& e) {
63758       {
63759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63760       };
63761     } catch (Dali::DaliException e) {
63762       {
63763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63764       };
63765     } catch (...) {
63766       {
63767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63768       };
63769     }
63770   }
63771
63772 }
63773
63774
63775 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
63776   unsigned int jresult ;
63777   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63778   bool result;
63779
63780   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63781   {
63782     try {
63783       result = (bool)(arg1)->IsKeyboardNavigationSupported();
63784     } catch (std::out_of_range& e) {
63785       {
63786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63787       };
63788     } catch (std::exception& e) {
63789       {
63790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63791       };
63792     } catch (Dali::DaliException e) {
63793       {
63794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63795       };
63796     } catch (...) {
63797       {
63798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63799       };
63800     }
63801   }
63802
63803   jresult = result;
63804   return jresult;
63805 }
63806
63807
63808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
63809   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63810
63811   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63812   {
63813     try {
63814       (arg1)->SetKeyInputFocus();
63815     } catch (std::out_of_range& e) {
63816       {
63817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63818       };
63819     } catch (std::exception& e) {
63820       {
63821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63822       };
63823     } catch (Dali::DaliException e) {
63824       {
63825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63826       };
63827     } catch (...) {
63828       {
63829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63830       };
63831     }
63832   }
63833
63834 }
63835
63836
63837 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
63838   unsigned int jresult ;
63839   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63840   bool result;
63841
63842   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63843   {
63844     try {
63845       result = (bool)(arg1)->HasKeyInputFocus();
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 = result;
63866   return jresult;
63867 }
63868
63869
63870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
63871   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63872
63873   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63874   {
63875     try {
63876       (arg1)->ClearKeyInputFocus();
63877     } catch (std::out_of_range& e) {
63878       {
63879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63880       };
63881     } catch (std::exception& e) {
63882       {
63883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63884       };
63885     } catch (Dali::DaliException e) {
63886       {
63887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63888       };
63889     } catch (...) {
63890       {
63891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63892       };
63893     }
63894   }
63895
63896 }
63897
63898
63899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
63900   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63901   bool arg2 ;
63902
63903   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63904   arg2 = jarg2 ? true : false;
63905   {
63906     try {
63907       (arg1)->SetAsKeyboardFocusGroup(arg2);
63908     } catch (std::out_of_range& e) {
63909       {
63910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63911       };
63912     } catch (std::exception& e) {
63913       {
63914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63915       };
63916     } catch (Dali::DaliException e) {
63917       {
63918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63919       };
63920     } catch (...) {
63921       {
63922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63923       };
63924     }
63925   }
63926
63927 }
63928
63929
63930 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
63931   unsigned int jresult ;
63932   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63933   bool result;
63934
63935   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63936   {
63937     try {
63938       result = (bool)(arg1)->IsKeyboardFocusGroup();
63939     } catch (std::out_of_range& e) {
63940       {
63941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63942       };
63943     } catch (std::exception& e) {
63944       {
63945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63946       };
63947     } catch (Dali::DaliException e) {
63948       {
63949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63950       };
63951     } catch (...) {
63952       {
63953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63954       };
63955     }
63956   }
63957
63958   jresult = result;
63959   return jresult;
63960 }
63961
63962
63963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_AccessibilityActivate(void * jarg1) {
63964   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63965
63966   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63967   {
63968     try {
63969       (arg1)->AccessibilityActivate();
63970     } catch (std::out_of_range& e) {
63971       {
63972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63973       };
63974     } catch (std::exception& e) {
63975       {
63976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63977       };
63978     } catch (Dali::DaliException e) {
63979       {
63980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63981       };
63982     } catch (...) {
63983       {
63984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63985       };
63986     }
63987   }
63988
63989 }
63990
63991
63992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_KeyboardEnter(void * jarg1) {
63993   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63994
63995   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63996   {
63997     try {
63998       (arg1)->KeyboardEnter();
63999     } catch (std::out_of_range& e) {
64000       {
64001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64002       };
64003     } catch (std::exception& e) {
64004       {
64005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64006       };
64007     } catch (Dali::DaliException e) {
64008       {
64009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64010       };
64011     } catch (...) {
64012       {
64013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64014       };
64015     }
64016   }
64017
64018 }
64019
64020
64021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
64022   void * jresult ;
64023   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64024   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
64025
64026   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64027   {
64028     try {
64029       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
64030     } catch (std::out_of_range& e) {
64031       {
64032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64033       };
64034     } catch (std::exception& e) {
64035       {
64036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64037       };
64038     } catch (Dali::DaliException e) {
64039       {
64040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64041       };
64042     } catch (...) {
64043       {
64044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64045       };
64046     }
64047   }
64048
64049   jresult = (void *)result;
64050   return jresult;
64051 }
64052
64053
64054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
64055   void * jresult ;
64056   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64057   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
64058
64059   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64060   {
64061     try {
64062       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
64063     } catch (std::out_of_range& e) {
64064       {
64065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64066       };
64067     } catch (std::exception& e) {
64068       {
64069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64070       };
64071     } catch (Dali::DaliException e) {
64072       {
64073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64074       };
64075     } catch (...) {
64076       {
64077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64078       };
64079     }
64080   }
64081
64082   jresult = (void *)result;
64083   return jresult;
64084 }
64085
64086
64087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
64088   void * jresult ;
64089   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64090   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
64091
64092   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64093   {
64094     try {
64095       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
64096     } catch (std::out_of_range& e) {
64097       {
64098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64099       };
64100     } catch (std::exception& e) {
64101       {
64102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64103       };
64104     } catch (Dali::DaliException e) {
64105       {
64106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64107       };
64108     } catch (...) {
64109       {
64110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64111       };
64112     }
64113   }
64114
64115   jresult = (void *)result;
64116   return jresult;
64117 }
64118
64119
64120 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_EmitKeyEventSignal(void * jarg1, void * jarg2) {
64121   unsigned int jresult ;
64122   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64123   Dali::KeyEvent *arg2 = 0 ;
64124   bool result;
64125
64126   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64127   arg2 = (Dali::KeyEvent *)jarg2;
64128   if (!arg2) {
64129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64130     return 0;
64131   }
64132   {
64133     try {
64134       result = (bool)(arg1)->EmitKeyEventSignal((Dali::KeyEvent const &)*arg2);
64135     } catch (std::out_of_range& e) {
64136       {
64137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64138       };
64139     } catch (std::exception& e) {
64140       {
64141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64142       };
64143     } catch (Dali::DaliException e) {
64144       {
64145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64146       };
64147     } catch (...) {
64148       {
64149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64150       };
64151     }
64152   }
64153
64154   jresult = result;
64155   return jresult;
64156 }
64157
64158
64159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
64160   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64161   int arg2 ;
64162   SwigDirector_ViewImpl *darg = 0;
64163
64164   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64165   arg2 = (int)jarg2;
64166   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64167   {
64168     try {
64169       (darg)->OnStageConnection(arg2);
64170     } catch (std::out_of_range& e) {
64171       {
64172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64173       };
64174     } catch (std::exception& e) {
64175       {
64176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64177       };
64178     } catch (Dali::DaliException e) {
64179       {
64180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64181       };
64182     } catch (...) {
64183       {
64184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64185       };
64186     }
64187   }
64188
64189 }
64190
64191
64192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
64193   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64194   int arg2 ;
64195   SwigDirector_ViewImpl *darg = 0;
64196
64197   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64198   arg2 = (int)jarg2;
64199   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64200   {
64201     try {
64202       (darg)->OnStageConnectionSwigPublic(arg2);
64203     } catch (std::out_of_range& e) {
64204       {
64205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64206       };
64207     } catch (std::exception& e) {
64208       {
64209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64210       };
64211     } catch (Dali::DaliException e) {
64212       {
64213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64214       };
64215     } catch (...) {
64216       {
64217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64218       };
64219     }
64220   }
64221
64222 }
64223
64224
64225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
64226   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64227   SwigDirector_ViewImpl *darg = 0;
64228
64229   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64230   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64231   {
64232     try {
64233       (darg)->OnStageDisconnection();
64234     } catch (std::out_of_range& e) {
64235       {
64236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64237       };
64238     } catch (std::exception& e) {
64239       {
64240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64241       };
64242     } catch (Dali::DaliException e) {
64243       {
64244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64245       };
64246     } catch (...) {
64247       {
64248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64249       };
64250     }
64251   }
64252
64253 }
64254
64255
64256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
64257   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64258   SwigDirector_ViewImpl *darg = 0;
64259
64260   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64261   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64262   {
64263     try {
64264       (darg)->OnStageDisconnectionSwigPublic();
64265     } catch (std::out_of_range& e) {
64266       {
64267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64268       };
64269     } catch (std::exception& e) {
64270       {
64271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64272       };
64273     } catch (Dali::DaliException e) {
64274       {
64275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64276       };
64277     } catch (...) {
64278       {
64279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64280       };
64281     }
64282   }
64283
64284 }
64285
64286
64287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
64288   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64289   Dali::Actor *arg2 = 0 ;
64290   SwigDirector_ViewImpl *darg = 0;
64291
64292   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64293   arg2 = (Dali::Actor *)jarg2;
64294   if (!arg2) {
64295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64296     return ;
64297   }
64298   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64299   {
64300     try {
64301       (darg)->OnChildAdd(*arg2);
64302     } catch (std::out_of_range& e) {
64303       {
64304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64305       };
64306     } catch (std::exception& e) {
64307       {
64308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64309       };
64310     } catch (Dali::DaliException e) {
64311       {
64312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64313       };
64314     } catch (...) {
64315       {
64316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64317       };
64318     }
64319   }
64320
64321 }
64322
64323
64324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64325   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64326   Dali::Actor *arg2 = 0 ;
64327   SwigDirector_ViewImpl *darg = 0;
64328
64329   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64330   arg2 = (Dali::Actor *)jarg2;
64331   if (!arg2) {
64332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64333     return ;
64334   }
64335   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64336   {
64337     try {
64338       (darg)->OnChildAddSwigPublic(*arg2);
64339     } catch (std::out_of_range& e) {
64340       {
64341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64342       };
64343     } catch (std::exception& e) {
64344       {
64345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64346       };
64347     } catch (Dali::DaliException e) {
64348       {
64349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64350       };
64351     } catch (...) {
64352       {
64353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64354       };
64355     }
64356   }
64357
64358 }
64359
64360
64361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
64362   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64363   Dali::Actor *arg2 = 0 ;
64364   SwigDirector_ViewImpl *darg = 0;
64365
64366   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64367   arg2 = (Dali::Actor *)jarg2;
64368   if (!arg2) {
64369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64370     return ;
64371   }
64372   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64373   {
64374     try {
64375       (darg)->OnChildRemove(*arg2);
64376     } catch (std::out_of_range& e) {
64377       {
64378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64379       };
64380     } catch (std::exception& e) {
64381       {
64382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64383       };
64384     } catch (Dali::DaliException e) {
64385       {
64386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64387       };
64388     } catch (...) {
64389       {
64390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64391       };
64392     }
64393   }
64394
64395 }
64396
64397
64398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64399   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64400   Dali::Actor *arg2 = 0 ;
64401   SwigDirector_ViewImpl *darg = 0;
64402
64403   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64404   arg2 = (Dali::Actor *)jarg2;
64405   if (!arg2) {
64406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64407     return ;
64408   }
64409   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64410   {
64411     try {
64412       (darg)->OnChildRemoveSwigPublic(*arg2);
64413     } catch (std::out_of_range& e) {
64414       {
64415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64416       };
64417     } catch (std::exception& e) {
64418       {
64419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64420       };
64421     } catch (Dali::DaliException e) {
64422       {
64423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64424       };
64425     } catch (...) {
64426       {
64427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64428       };
64429     }
64430   }
64431
64432 }
64433
64434
64435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
64436   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64437   Dali::Property::Index arg2 ;
64438   Dali::Property::Value arg3 ;
64439   Dali::Property::Value *argp3 ;
64440   SwigDirector_ViewImpl *darg = 0;
64441
64442   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64443   arg2 = (Dali::Property::Index)jarg2;
64444   argp3 = (Dali::Property::Value *)jarg3;
64445   if (!argp3) {
64446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64447     return ;
64448   }
64449   arg3 = *argp3;
64450   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64451   {
64452     try {
64453       (darg)->OnPropertySet(arg2,arg3);
64454     } catch (std::out_of_range& e) {
64455       {
64456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64457       };
64458     } catch (std::exception& e) {
64459       {
64460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64461       };
64462     } catch (Dali::DaliException e) {
64463       {
64464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64465       };
64466     } catch (...) {
64467       {
64468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64469       };
64470     }
64471   }
64472
64473 }
64474
64475
64476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
64477   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64478   Dali::Property::Index arg2 ;
64479   Dali::Property::Value arg3 ;
64480   Dali::Property::Value *argp3 ;
64481   SwigDirector_ViewImpl *darg = 0;
64482
64483   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64484   arg2 = (Dali::Property::Index)jarg2;
64485   argp3 = (Dali::Property::Value *)jarg3;
64486   if (!argp3) {
64487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64488     return ;
64489   }
64490   arg3 = *argp3;
64491   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64492   {
64493     try {
64494       (darg)->OnPropertySetSwigPublic(arg2,arg3);
64495     } catch (std::out_of_range& e) {
64496       {
64497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64498       };
64499     } catch (std::exception& e) {
64500       {
64501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64502       };
64503     } catch (Dali::DaliException e) {
64504       {
64505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64506       };
64507     } catch (...) {
64508       {
64509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64510       };
64511     }
64512   }
64513
64514 }
64515
64516
64517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
64518   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64519   Dali::Vector3 *arg2 = 0 ;
64520   SwigDirector_ViewImpl *darg = 0;
64521
64522   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64523   arg2 = (Dali::Vector3 *)jarg2;
64524   if (!arg2) {
64525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64526     return ;
64527   }
64528   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64529   {
64530     try {
64531       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
64532     } catch (std::out_of_range& e) {
64533       {
64534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64535       };
64536     } catch (std::exception& e) {
64537       {
64538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64539       };
64540     } catch (Dali::DaliException e) {
64541       {
64542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64543       };
64544     } catch (...) {
64545       {
64546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64547       };
64548     }
64549   }
64550
64551 }
64552
64553
64554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64555   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64556   Dali::Vector3 *arg2 = 0 ;
64557   SwigDirector_ViewImpl *darg = 0;
64558
64559   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64560   arg2 = (Dali::Vector3 *)jarg2;
64561   if (!arg2) {
64562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64563     return ;
64564   }
64565   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64566   {
64567     try {
64568       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
64569     } catch (std::out_of_range& e) {
64570       {
64571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64572       };
64573     } catch (std::exception& e) {
64574       {
64575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64576       };
64577     } catch (Dali::DaliException e) {
64578       {
64579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64580       };
64581     } catch (...) {
64582       {
64583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64584       };
64585     }
64586   }
64587
64588 }
64589
64590
64591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
64592   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64593   Dali::Animation *arg2 = 0 ;
64594   Dali::Vector3 *arg3 = 0 ;
64595   SwigDirector_ViewImpl *darg = 0;
64596
64597   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64598   arg2 = (Dali::Animation *)jarg2;
64599   if (!arg2) {
64600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64601     return ;
64602   }
64603   arg3 = (Dali::Vector3 *)jarg3;
64604   if (!arg3) {
64605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64606     return ;
64607   }
64608   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64609   {
64610     try {
64611       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
64612     } catch (std::out_of_range& e) {
64613       {
64614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64615       };
64616     } catch (std::exception& e) {
64617       {
64618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64619       };
64620     } catch (Dali::DaliException e) {
64621       {
64622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64623       };
64624     } catch (...) {
64625       {
64626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64627       };
64628     }
64629   }
64630
64631 }
64632
64633
64634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64635   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64636   Dali::Animation *arg2 = 0 ;
64637   Dali::Vector3 *arg3 = 0 ;
64638   SwigDirector_ViewImpl *darg = 0;
64639
64640   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64641   arg2 = (Dali::Animation *)jarg2;
64642   if (!arg2) {
64643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64644     return ;
64645   }
64646   arg3 = (Dali::Vector3 *)jarg3;
64647   if (!arg3) {
64648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64649     return ;
64650   }
64651   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64652   {
64653     try {
64654       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
64655     } catch (std::out_of_range& e) {
64656       {
64657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64658       };
64659     } catch (std::exception& e) {
64660       {
64661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64662       };
64663     } catch (Dali::DaliException e) {
64664       {
64665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64666       };
64667     } catch (...) {
64668       {
64669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64670       };
64671     }
64672   }
64673
64674 }
64675
64676
64677 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
64678   unsigned int jresult ;
64679   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64680   Dali::TouchEvent *arg2 = 0 ;
64681   SwigDirector_ViewImpl *darg = 0;
64682   bool result;
64683
64684   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64685   arg2 = (Dali::TouchEvent *)jarg2;
64686   if (!arg2) {
64687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64688     return 0;
64689   }
64690   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64691   {
64692     try {
64693       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
64694     } catch (std::out_of_range& e) {
64695       {
64696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64697       };
64698     } catch (std::exception& e) {
64699       {
64700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64701       };
64702     } catch (Dali::DaliException e) {
64703       {
64704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64705       };
64706     } catch (...) {
64707       {
64708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64709       };
64710     }
64711   }
64712
64713   jresult = result;
64714   return jresult;
64715 }
64716
64717
64718 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64719   unsigned int jresult ;
64720   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64721   Dali::TouchEvent *arg2 = 0 ;
64722   SwigDirector_ViewImpl *darg = 0;
64723   bool result;
64724
64725   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64726   arg2 = (Dali::TouchEvent *)jarg2;
64727   if (!arg2) {
64728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64729     return 0;
64730   }
64731   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64732   {
64733     try {
64734       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
64735     } catch (std::out_of_range& e) {
64736       {
64737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64738       };
64739     } catch (std::exception& e) {
64740       {
64741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64742       };
64743     } catch (Dali::DaliException e) {
64744       {
64745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64746       };
64747     } catch (...) {
64748       {
64749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64750       };
64751     }
64752   }
64753
64754   jresult = result;
64755   return jresult;
64756 }
64757
64758
64759 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
64760   unsigned int jresult ;
64761   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64762   Dali::HoverEvent *arg2 = 0 ;
64763   SwigDirector_ViewImpl *darg = 0;
64764   bool result;
64765
64766   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64767   arg2 = (Dali::HoverEvent *)jarg2;
64768   if (!arg2) {
64769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64770     return 0;
64771   }
64772   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64773   {
64774     try {
64775       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
64776     } catch (std::out_of_range& e) {
64777       {
64778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64779       };
64780     } catch (std::exception& e) {
64781       {
64782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64783       };
64784     } catch (Dali::DaliException e) {
64785       {
64786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64787       };
64788     } catch (...) {
64789       {
64790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64791       };
64792     }
64793   }
64794
64795   jresult = result;
64796   return jresult;
64797 }
64798
64799
64800 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64801   unsigned int jresult ;
64802   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64803   Dali::HoverEvent *arg2 = 0 ;
64804   SwigDirector_ViewImpl *darg = 0;
64805   bool result;
64806
64807   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64808   arg2 = (Dali::HoverEvent *)jarg2;
64809   if (!arg2) {
64810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64811     return 0;
64812   }
64813   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64814   {
64815     try {
64816       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
64817     } catch (std::out_of_range& e) {
64818       {
64819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64820       };
64821     } catch (std::exception& e) {
64822       {
64823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64824       };
64825     } catch (Dali::DaliException e) {
64826       {
64827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64828       };
64829     } catch (...) {
64830       {
64831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64832       };
64833     }
64834   }
64835
64836   jresult = result;
64837   return jresult;
64838 }
64839
64840
64841 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
64842   unsigned int jresult ;
64843   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64844   Dali::KeyEvent *arg2 = 0 ;
64845   SwigDirector_ViewImpl *darg = 0;
64846   bool result;
64847
64848   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64849   arg2 = (Dali::KeyEvent *)jarg2;
64850   if (!arg2) {
64851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64852     return 0;
64853   }
64854   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64855   {
64856     try {
64857       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
64858     } catch (std::out_of_range& e) {
64859       {
64860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64861       };
64862     } catch (std::exception& e) {
64863       {
64864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64865       };
64866     } catch (Dali::DaliException e) {
64867       {
64868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64869       };
64870     } catch (...) {
64871       {
64872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64873       };
64874     }
64875   }
64876
64877   jresult = result;
64878   return jresult;
64879 }
64880
64881
64882 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64883   unsigned int jresult ;
64884   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64885   Dali::KeyEvent *arg2 = 0 ;
64886   SwigDirector_ViewImpl *darg = 0;
64887   bool result;
64888
64889   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64890   arg2 = (Dali::KeyEvent *)jarg2;
64891   if (!arg2) {
64892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64893     return 0;
64894   }
64895   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64896   {
64897     try {
64898       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
64899     } catch (std::out_of_range& e) {
64900       {
64901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64902       };
64903     } catch (std::exception& e) {
64904       {
64905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64906       };
64907     } catch (Dali::DaliException e) {
64908       {
64909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64910       };
64911     } catch (...) {
64912       {
64913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64914       };
64915     }
64916   }
64917
64918   jresult = result;
64919   return jresult;
64920 }
64921
64922
64923 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
64924   unsigned int jresult ;
64925   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64926   Dali::WheelEvent *arg2 = 0 ;
64927   SwigDirector_ViewImpl *darg = 0;
64928   bool result;
64929
64930   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64931   arg2 = (Dali::WheelEvent *)jarg2;
64932   if (!arg2) {
64933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64934     return 0;
64935   }
64936   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64937   {
64938     try {
64939       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
64940     } catch (std::out_of_range& e) {
64941       {
64942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64943       };
64944     } catch (std::exception& e) {
64945       {
64946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64947       };
64948     } catch (Dali::DaliException e) {
64949       {
64950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64951       };
64952     } catch (...) {
64953       {
64954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64955       };
64956     }
64957   }
64958
64959   jresult = result;
64960   return jresult;
64961 }
64962
64963
64964 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64965   unsigned int jresult ;
64966   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64967   Dali::WheelEvent *arg2 = 0 ;
64968   SwigDirector_ViewImpl *darg = 0;
64969   bool result;
64970
64971   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64972   arg2 = (Dali::WheelEvent *)jarg2;
64973   if (!arg2) {
64974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64975     return 0;
64976   }
64977   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64978   {
64979     try {
64980       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
64981     } catch (std::out_of_range& e) {
64982       {
64983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64984       };
64985     } catch (std::exception& e) {
64986       {
64987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64988       };
64989     } catch (Dali::DaliException e) {
64990       {
64991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64992       };
64993     } catch (...) {
64994       {
64995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64996       };
64997     }
64998   }
64999
65000   jresult = result;
65001   return jresult;
65002 }
65003
65004
65005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
65006   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65007   Dali::Vector2 *arg2 = 0 ;
65008   Dali::RelayoutContainer *arg3 = 0 ;
65009   SwigDirector_ViewImpl *darg = 0;
65010
65011   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65012   arg2 = (Dali::Vector2 *)jarg2;
65013   if (!arg2) {
65014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
65015     return ;
65016   }
65017   arg3 = (Dali::RelayoutContainer *)jarg3;
65018   if (!arg3) {
65019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
65020     return ;
65021   }
65022   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65023   {
65024     try {
65025       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
65026     } catch (std::out_of_range& e) {
65027       {
65028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65029       };
65030     } catch (std::exception& e) {
65031       {
65032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65033       };
65034     } catch (Dali::DaliException e) {
65035       {
65036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65037       };
65038     } catch (...) {
65039       {
65040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65041       };
65042     }
65043   }
65044
65045 }
65046
65047
65048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
65049   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65050   Dali::Vector2 *arg2 = 0 ;
65051   Dali::RelayoutContainer *arg3 = 0 ;
65052   SwigDirector_ViewImpl *darg = 0;
65053
65054   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65055   arg2 = (Dali::Vector2 *)jarg2;
65056   if (!arg2) {
65057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
65058     return ;
65059   }
65060   arg3 = (Dali::RelayoutContainer *)jarg3;
65061   if (!arg3) {
65062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
65063     return ;
65064   }
65065   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65066   {
65067     try {
65068       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
65069     } catch (std::out_of_range& e) {
65070       {
65071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65072       };
65073     } catch (std::exception& e) {
65074       {
65075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65076       };
65077     } catch (Dali::DaliException e) {
65078       {
65079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65080       };
65081     } catch (...) {
65082       {
65083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65084       };
65085     }
65086   }
65087
65088 }
65089
65090
65091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
65092   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65093   Dali::ResizePolicy::Type arg2 ;
65094   Dali::Dimension::Type arg3 ;
65095   SwigDirector_ViewImpl *darg = 0;
65096
65097   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65098   arg2 = (Dali::ResizePolicy::Type)jarg2;
65099   arg3 = (Dali::Dimension::Type)jarg3;
65100   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65101   {
65102     try {
65103       (darg)->OnSetResizePolicy(arg2,arg3);
65104     } catch (std::out_of_range& e) {
65105       {
65106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65107       };
65108     } catch (std::exception& e) {
65109       {
65110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65111       };
65112     } catch (Dali::DaliException e) {
65113       {
65114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65115       };
65116     } catch (...) {
65117       {
65118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65119       };
65120     }
65121   }
65122
65123 }
65124
65125
65126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
65127   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65128   Dali::ResizePolicy::Type arg2 ;
65129   Dali::Dimension::Type arg3 ;
65130   SwigDirector_ViewImpl *darg = 0;
65131
65132   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65133   arg2 = (Dali::ResizePolicy::Type)jarg2;
65134   arg3 = (Dali::Dimension::Type)jarg3;
65135   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65136   {
65137     try {
65138       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
65139     } catch (std::out_of_range& e) {
65140       {
65141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65142       };
65143     } catch (std::exception& e) {
65144       {
65145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65146       };
65147     } catch (Dali::DaliException e) {
65148       {
65149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65150       };
65151     } catch (...) {
65152       {
65153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65154       };
65155     }
65156   }
65157
65158 }
65159
65160
65161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
65162   void * jresult ;
65163   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65164   SwigDirector_ViewImpl *darg = 0;
65165   Dali::Vector3 result;
65166
65167   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65168   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65169   {
65170     try {
65171       result = (darg)->GetNaturalSize();
65172     } catch (std::out_of_range& e) {
65173       {
65174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65175       };
65176     } catch (std::exception& e) {
65177       {
65178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65179       };
65180     } catch (Dali::DaliException e) {
65181       {
65182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65183       };
65184     } catch (...) {
65185       {
65186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65187       };
65188     }
65189   }
65190
65191   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65192   return jresult;
65193 }
65194
65195
65196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
65197   void * jresult ;
65198   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65199   SwigDirector_ViewImpl *darg = 0;
65200   Dali::Vector3 result;
65201
65202   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65203   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65204   {
65205     try {
65206       result = (darg)->GetNaturalSizeSwigPublic();
65207     } catch (std::out_of_range& e) {
65208       {
65209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65210       };
65211     } catch (std::exception& e) {
65212       {
65213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65214       };
65215     } catch (Dali::DaliException e) {
65216       {
65217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65218       };
65219     } catch (...) {
65220       {
65221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65222       };
65223     }
65224   }
65225
65226   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65227   return jresult;
65228 }
65229
65230
65231 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
65232   float jresult ;
65233   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65234   Dali::Actor *arg2 = 0 ;
65235   Dali::Dimension::Type arg3 ;
65236   SwigDirector_ViewImpl *darg = 0;
65237   float result;
65238
65239   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65240   arg2 = (Dali::Actor *)jarg2;
65241   if (!arg2) {
65242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65243     return 0;
65244   }
65245   arg3 = (Dali::Dimension::Type)jarg3;
65246   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65247   {
65248     try {
65249       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
65250     } catch (std::out_of_range& e) {
65251       {
65252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65253       };
65254     } catch (std::exception& e) {
65255       {
65256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65257       };
65258     } catch (Dali::DaliException e) {
65259       {
65260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65261       };
65262     } catch (...) {
65263       {
65264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65265       };
65266     }
65267   }
65268
65269   jresult = result;
65270   return jresult;
65271 }
65272
65273
65274 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65275   float jresult ;
65276   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65277   Dali::Actor *arg2 = 0 ;
65278   Dali::Dimension::Type arg3 ;
65279   SwigDirector_ViewImpl *darg = 0;
65280   float result;
65281
65282   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65283   arg2 = (Dali::Actor *)jarg2;
65284   if (!arg2) {
65285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65286     return 0;
65287   }
65288   arg3 = (Dali::Dimension::Type)jarg3;
65289   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65290   {
65291     try {
65292       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
65293     } catch (std::out_of_range& e) {
65294       {
65295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65296       };
65297     } catch (std::exception& e) {
65298       {
65299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65300       };
65301     } catch (Dali::DaliException e) {
65302       {
65303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65304       };
65305     } catch (...) {
65306       {
65307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65308       };
65309     }
65310   }
65311
65312   jresult = result;
65313   return jresult;
65314 }
65315
65316
65317 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
65318   float jresult ;
65319   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65320   float arg2 ;
65321   SwigDirector_ViewImpl *darg = 0;
65322   float result;
65323
65324   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65325   arg2 = (float)jarg2;
65326   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65327   {
65328     try {
65329       result = (float)(darg)->GetHeightForWidth(arg2);
65330     } catch (std::out_of_range& e) {
65331       {
65332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65333       };
65334     } catch (std::exception& e) {
65335       {
65336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65337       };
65338     } catch (Dali::DaliException e) {
65339       {
65340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65341       };
65342     } catch (...) {
65343       {
65344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65345       };
65346     }
65347   }
65348
65349   jresult = result;
65350   return jresult;
65351 }
65352
65353
65354 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
65355   float jresult ;
65356   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65357   float arg2 ;
65358   SwigDirector_ViewImpl *darg = 0;
65359   float result;
65360
65361   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65362   arg2 = (float)jarg2;
65363   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65364   {
65365     try {
65366       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
65367     } catch (std::out_of_range& e) {
65368       {
65369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65370       };
65371     } catch (std::exception& e) {
65372       {
65373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65374       };
65375     } catch (Dali::DaliException e) {
65376       {
65377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65378       };
65379     } catch (...) {
65380       {
65381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65382       };
65383     }
65384   }
65385
65386   jresult = result;
65387   return jresult;
65388 }
65389
65390
65391 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
65392   float jresult ;
65393   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65394   float arg2 ;
65395   SwigDirector_ViewImpl *darg = 0;
65396   float result;
65397
65398   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65399   arg2 = (float)jarg2;
65400   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65401   {
65402     try {
65403       result = (float)(darg)->GetWidthForHeight(arg2);
65404     } catch (std::out_of_range& e) {
65405       {
65406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65407       };
65408     } catch (std::exception& e) {
65409       {
65410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65411       };
65412     } catch (Dali::DaliException e) {
65413       {
65414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65415       };
65416     } catch (...) {
65417       {
65418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65419       };
65420     }
65421   }
65422
65423   jresult = result;
65424   return jresult;
65425 }
65426
65427
65428 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
65429   float jresult ;
65430   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65431   float arg2 ;
65432   SwigDirector_ViewImpl *darg = 0;
65433   float result;
65434
65435   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65436   arg2 = (float)jarg2;
65437   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65438   {
65439     try {
65440       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
65441     } catch (std::out_of_range& e) {
65442       {
65443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65444       };
65445     } catch (std::exception& e) {
65446       {
65447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65448       };
65449     } catch (Dali::DaliException e) {
65450       {
65451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65452       };
65453     } catch (...) {
65454       {
65455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65456       };
65457     }
65458   }
65459
65460   jresult = result;
65461   return jresult;
65462 }
65463
65464
65465 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
65466   unsigned int jresult ;
65467   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65468   Dali::Dimension::Type arg2 ;
65469   SwigDirector_ViewImpl *darg = 0;
65470   bool result;
65471
65472   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65473   arg2 = (Dali::Dimension::Type)jarg2;
65474   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65475   {
65476     try {
65477       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
65478     } catch (std::out_of_range& e) {
65479       {
65480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65481       };
65482     } catch (std::exception& e) {
65483       {
65484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65485       };
65486     } catch (Dali::DaliException e) {
65487       {
65488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65489       };
65490     } catch (...) {
65491       {
65492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65493       };
65494     }
65495   }
65496
65497   jresult = result;
65498   return jresult;
65499 }
65500
65501
65502 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
65503   unsigned int jresult ;
65504   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65505   Dali::Dimension::Type arg2 ;
65506   SwigDirector_ViewImpl *darg = 0;
65507   bool result;
65508
65509   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65510   arg2 = (Dali::Dimension::Type)jarg2;
65511   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65512   {
65513     try {
65514       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
65515     } catch (std::out_of_range& e) {
65516       {
65517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65518       };
65519     } catch (std::exception& e) {
65520       {
65521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65522       };
65523     } catch (Dali::DaliException e) {
65524       {
65525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65526       };
65527     } catch (...) {
65528       {
65529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65530       };
65531     }
65532   }
65533
65534   jresult = result;
65535   return jresult;
65536 }
65537
65538
65539 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
65540   unsigned int jresult ;
65541   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65542   SwigDirector_ViewImpl *darg = 0;
65543   bool result;
65544
65545   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65546   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65547   {
65548     try {
65549       result = (bool)(darg)->RelayoutDependentOnChildren();
65550     } catch (std::out_of_range& e) {
65551       {
65552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65553       };
65554     } catch (std::exception& e) {
65555       {
65556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65557       };
65558     } catch (Dali::DaliException e) {
65559       {
65560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65561       };
65562     } catch (...) {
65563       {
65564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65565       };
65566     }
65567   }
65568
65569   jresult = result;
65570   return jresult;
65571 }
65572
65573
65574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
65575   unsigned int jresult ;
65576   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65577   SwigDirector_ViewImpl *darg = 0;
65578   bool result;
65579
65580   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65581   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65582   {
65583     try {
65584       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
65585     } catch (std::out_of_range& e) {
65586       {
65587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65588       };
65589     } catch (std::exception& e) {
65590       {
65591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65592       };
65593     } catch (Dali::DaliException e) {
65594       {
65595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65596       };
65597     } catch (...) {
65598       {
65599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65600       };
65601     }
65602   }
65603
65604   jresult = result;
65605   return jresult;
65606 }
65607
65608
65609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
65610   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65611   Dali::Dimension::Type arg2 ;
65612   SwigDirector_ViewImpl *darg = 0;
65613
65614   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65615   arg2 = (Dali::Dimension::Type)jarg2;
65616   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65617   {
65618     try {
65619       (darg)->OnCalculateRelayoutSize(arg2);
65620     } catch (std::out_of_range& e) {
65621       {
65622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65623       };
65624     } catch (std::exception& e) {
65625       {
65626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65627       };
65628     } catch (Dali::DaliException e) {
65629       {
65630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65631       };
65632     } catch (...) {
65633       {
65634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65635       };
65636     }
65637   }
65638
65639 }
65640
65641
65642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
65643   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65644   Dali::Dimension::Type arg2 ;
65645   SwigDirector_ViewImpl *darg = 0;
65646
65647   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65648   arg2 = (Dali::Dimension::Type)jarg2;
65649   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65650   {
65651     try {
65652       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
65653     } catch (std::out_of_range& e) {
65654       {
65655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65656       };
65657     } catch (std::exception& e) {
65658       {
65659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65660       };
65661     } catch (Dali::DaliException e) {
65662       {
65663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65664       };
65665     } catch (...) {
65666       {
65667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65668       };
65669     }
65670   }
65671
65672 }
65673
65674
65675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
65676   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65677   float arg2 ;
65678   Dali::Dimension::Type arg3 ;
65679   SwigDirector_ViewImpl *darg = 0;
65680
65681   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65682   arg2 = (float)jarg2;
65683   arg3 = (Dali::Dimension::Type)jarg3;
65684   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65685   {
65686     try {
65687       (darg)->OnLayoutNegotiated(arg2,arg3);
65688     } catch (std::out_of_range& e) {
65689       {
65690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65691       };
65692     } catch (std::exception& e) {
65693       {
65694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65695       };
65696     } catch (Dali::DaliException e) {
65697       {
65698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65699       };
65700     } catch (...) {
65701       {
65702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65703       };
65704     }
65705   }
65706
65707 }
65708
65709
65710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
65711   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65712   float arg2 ;
65713   Dali::Dimension::Type arg3 ;
65714   SwigDirector_ViewImpl *darg = 0;
65715
65716   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65717   arg2 = (float)jarg2;
65718   arg3 = (Dali::Dimension::Type)jarg3;
65719   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65720   {
65721     try {
65722       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
65723     } catch (std::out_of_range& e) {
65724       {
65725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65726       };
65727     } catch (std::exception& e) {
65728       {
65729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65730       };
65731     } catch (Dali::DaliException e) {
65732       {
65733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65734       };
65735     } catch (...) {
65736       {
65737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65738       };
65739     }
65740   }
65741
65742 }
65743
65744
65745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
65746   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65747
65748   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65749   {
65750     try {
65751       (arg1)->OnInitialize();
65752     } catch (std::out_of_range& e) {
65753       {
65754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65755       };
65756     } catch (std::exception& e) {
65757       {
65758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65759       };
65760     } catch (Dali::DaliException e) {
65761       {
65762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65763       };
65764     } catch (...) {
65765       {
65766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65767       };
65768     }
65769   }
65770
65771 }
65772
65773
65774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
65775   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65776
65777   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65778   {
65779     try {
65780       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
65781     } catch (std::out_of_range& e) {
65782       {
65783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65784       };
65785     } catch (std::exception& e) {
65786       {
65787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65788       };
65789     } catch (Dali::DaliException e) {
65790       {
65791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65792       };
65793     } catch (...) {
65794       {
65795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65796       };
65797     }
65798   }
65799
65800 }
65801
65802
65803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
65804   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65805   Dali::Actor *arg2 = 0 ;
65806
65807   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65808   arg2 = (Dali::Actor *)jarg2;
65809   if (!arg2) {
65810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65811     return ;
65812   }
65813   {
65814     try {
65815       (arg1)->OnControlChildAdd(*arg2);
65816     } catch (std::out_of_range& e) {
65817       {
65818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65819       };
65820     } catch (std::exception& e) {
65821       {
65822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65823       };
65824     } catch (Dali::DaliException e) {
65825       {
65826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65827       };
65828     } catch (...) {
65829       {
65830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65831       };
65832     }
65833   }
65834
65835 }
65836
65837
65838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65839   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65840   Dali::Actor *arg2 = 0 ;
65841
65842   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65843   arg2 = (Dali::Actor *)jarg2;
65844   if (!arg2) {
65845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65846     return ;
65847   }
65848   {
65849     try {
65850       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
65851     } catch (std::out_of_range& e) {
65852       {
65853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65854       };
65855     } catch (std::exception& e) {
65856       {
65857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65858       };
65859     } catch (Dali::DaliException e) {
65860       {
65861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65862       };
65863     } catch (...) {
65864       {
65865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65866       };
65867     }
65868   }
65869
65870 }
65871
65872
65873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
65874   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65875   Dali::Actor *arg2 = 0 ;
65876
65877   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65878   arg2 = (Dali::Actor *)jarg2;
65879   if (!arg2) {
65880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65881     return ;
65882   }
65883   {
65884     try {
65885       (arg1)->OnControlChildRemove(*arg2);
65886     } catch (std::out_of_range& e) {
65887       {
65888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65889       };
65890     } catch (std::exception& e) {
65891       {
65892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65893       };
65894     } catch (Dali::DaliException e) {
65895       {
65896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65897       };
65898     } catch (...) {
65899       {
65900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65901       };
65902     }
65903   }
65904
65905 }
65906
65907
65908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65909   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65910   Dali::Actor *arg2 = 0 ;
65911
65912   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65913   arg2 = (Dali::Actor *)jarg2;
65914   if (!arg2) {
65915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65916     return ;
65917   }
65918   {
65919     try {
65920       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
65921     } catch (std::out_of_range& e) {
65922       {
65923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65924       };
65925     } catch (std::exception& e) {
65926       {
65927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65928       };
65929     } catch (Dali::DaliException e) {
65930       {
65931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65932       };
65933     } catch (...) {
65934       {
65935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65936       };
65937     }
65938   }
65939
65940 }
65941
65942
65943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
65944   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65945   Dali::Toolkit::StyleManager arg2 ;
65946   Dali::StyleChange::Type arg3 ;
65947   Dali::Toolkit::StyleManager *argp2 ;
65948
65949   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65950   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65951   if (!argp2) {
65952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65953     return ;
65954   }
65955   arg2 = *argp2;
65956   arg3 = (Dali::StyleChange::Type)jarg3;
65957   {
65958     try {
65959       (arg1)->OnStyleChange(arg2,arg3);
65960     } catch (std::out_of_range& e) {
65961       {
65962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65963       };
65964     } catch (std::exception& e) {
65965       {
65966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65967       };
65968     } catch (Dali::DaliException e) {
65969       {
65970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65971       };
65972     } catch (...) {
65973       {
65974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65975       };
65976     }
65977   }
65978
65979 }
65980
65981
65982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65983   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65984   Dali::Toolkit::StyleManager arg2 ;
65985   Dali::StyleChange::Type arg3 ;
65986   Dali::Toolkit::StyleManager *argp2 ;
65987
65988   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65989   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65990   if (!argp2) {
65991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65992     return ;
65993   }
65994   arg2 = *argp2;
65995   arg3 = (Dali::StyleChange::Type)jarg3;
65996   {
65997     try {
65998       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
65999     } catch (std::out_of_range& e) {
66000       {
66001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66002       };
66003     } catch (std::exception& e) {
66004       {
66005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66006       };
66007     } catch (Dali::DaliException e) {
66008       {
66009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66010       };
66011     } catch (...) {
66012       {
66013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66014       };
66015     }
66016   }
66017
66018 }
66019
66020
66021 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
66022   unsigned int jresult ;
66023   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66024   bool result;
66025
66026   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66027   {
66028     try {
66029       result = (bool)(arg1)->OnAccessibilityActivated();
66030     } catch (std::out_of_range& e) {
66031       {
66032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66033       };
66034     } catch (std::exception& e) {
66035       {
66036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66037       };
66038     } catch (Dali::DaliException e) {
66039       {
66040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66041       };
66042     } catch (...) {
66043       {
66044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66045       };
66046     }
66047   }
66048
66049   jresult = result;
66050   return jresult;
66051 }
66052
66053
66054 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
66055   unsigned int jresult ;
66056   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66057   bool result;
66058
66059   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66060   {
66061     try {
66062       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
66063     } catch (std::out_of_range& e) {
66064       {
66065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66066       };
66067     } catch (std::exception& e) {
66068       {
66069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66070       };
66071     } catch (Dali::DaliException e) {
66072       {
66073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66074       };
66075     } catch (...) {
66076       {
66077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66078       };
66079     }
66080   }
66081
66082   jresult = result;
66083   return jresult;
66084 }
66085
66086
66087 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
66088   unsigned int jresult ;
66089   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66090   Dali::PanGesture arg2 ;
66091   Dali::PanGesture *argp2 ;
66092   bool result;
66093
66094   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66095   argp2 = (Dali::PanGesture *)jarg2;
66096   if (!argp2) {
66097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
66098     return 0;
66099   }
66100   arg2 = *argp2;
66101   {
66102     try {
66103       result = (bool)(arg1)->OnAccessibilityPan(arg2);
66104     } catch (std::out_of_range& e) {
66105       {
66106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66107       };
66108     } catch (std::exception& e) {
66109       {
66110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66111       };
66112     } catch (Dali::DaliException e) {
66113       {
66114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66115       };
66116     } catch (...) {
66117       {
66118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66119       };
66120     }
66121   }
66122
66123   jresult = result;
66124   return jresult;
66125 }
66126
66127
66128 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66129   unsigned int jresult ;
66130   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66131   Dali::PanGesture arg2 ;
66132   Dali::PanGesture *argp2 ;
66133   bool result;
66134
66135   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66136   argp2 = (Dali::PanGesture *)jarg2;
66137   if (!argp2) {
66138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
66139     return 0;
66140   }
66141   arg2 = *argp2;
66142   {
66143     try {
66144       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
66145     } catch (std::out_of_range& e) {
66146       {
66147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66148       };
66149     } catch (std::exception& e) {
66150       {
66151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66152       };
66153     } catch (Dali::DaliException e) {
66154       {
66155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66156       };
66157     } catch (...) {
66158       {
66159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66160       };
66161     }
66162   }
66163
66164   jresult = result;
66165   return jresult;
66166 }
66167
66168
66169 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
66170   unsigned int jresult ;
66171   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66172   Dali::TouchEvent *arg2 = 0 ;
66173   bool result;
66174
66175   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66176   arg2 = (Dali::TouchEvent *)jarg2;
66177   if (!arg2) {
66178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
66179     return 0;
66180   }
66181   {
66182     try {
66183       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66184     } catch (std::out_of_range& e) {
66185       {
66186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66187       };
66188     } catch (std::exception& e) {
66189       {
66190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66191       };
66192     } catch (Dali::DaliException e) {
66193       {
66194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66195       };
66196     } catch (...) {
66197       {
66198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66199       };
66200     }
66201   }
66202
66203   jresult = result;
66204   return jresult;
66205 }
66206
66207
66208 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66209   unsigned int jresult ;
66210   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66211   Dali::TouchEvent *arg2 = 0 ;
66212   bool result;
66213
66214   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66215   arg2 = (Dali::TouchEvent *)jarg2;
66216   if (!arg2) {
66217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
66218     return 0;
66219   }
66220   {
66221     try {
66222       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66223     } catch (std::out_of_range& e) {
66224       {
66225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66226       };
66227     } catch (std::exception& e) {
66228       {
66229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66230       };
66231     } catch (Dali::DaliException e) {
66232       {
66233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66234       };
66235     } catch (...) {
66236       {
66237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66238       };
66239     }
66240   }
66241
66242   jresult = result;
66243   return jresult;
66244 }
66245
66246
66247 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
66248   unsigned int jresult ;
66249   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66250   bool arg2 ;
66251   bool result;
66252
66253   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66254   arg2 = jarg2 ? true : false;
66255   {
66256     try {
66257       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
66258     } catch (std::out_of_range& e) {
66259       {
66260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66261       };
66262     } catch (std::exception& e) {
66263       {
66264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66265       };
66266     } catch (Dali::DaliException e) {
66267       {
66268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66269       };
66270     } catch (...) {
66271       {
66272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66273       };
66274     }
66275   }
66276
66277   jresult = result;
66278   return jresult;
66279 }
66280
66281
66282 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
66283   unsigned int jresult ;
66284   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66285   bool arg2 ;
66286   bool result;
66287
66288   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66289   arg2 = jarg2 ? true : false;
66290   {
66291     try {
66292       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
66293     } catch (std::out_of_range& e) {
66294       {
66295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66296       };
66297     } catch (std::exception& e) {
66298       {
66299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66300       };
66301     } catch (Dali::DaliException e) {
66302       {
66303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66304       };
66305     } catch (...) {
66306       {
66307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66308       };
66309     }
66310   }
66311
66312   jresult = result;
66313   return jresult;
66314 }
66315
66316
66317 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
66318   unsigned int jresult ;
66319   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66320   bool result;
66321
66322   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66323   {
66324     try {
66325       result = (bool)(arg1)->OnAccessibilityZoom();
66326     } catch (std::out_of_range& e) {
66327       {
66328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66329       };
66330     } catch (std::exception& e) {
66331       {
66332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66333       };
66334     } catch (Dali::DaliException e) {
66335       {
66336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66337       };
66338     } catch (...) {
66339       {
66340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66341       };
66342     }
66343   }
66344
66345   jresult = result;
66346   return jresult;
66347 }
66348
66349
66350 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
66351   unsigned int jresult ;
66352   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66353   bool result;
66354
66355   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66356   {
66357     try {
66358       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
66359     } catch (std::out_of_range& e) {
66360       {
66361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66362       };
66363     } catch (std::exception& e) {
66364       {
66365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66366       };
66367     } catch (Dali::DaliException e) {
66368       {
66369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66370       };
66371     } catch (...) {
66372       {
66373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66374       };
66375     }
66376   }
66377
66378   jresult = result;
66379   return jresult;
66380 }
66381
66382
66383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
66384   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66385
66386   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66387   {
66388     try {
66389       (arg1)->OnKeyInputFocusGained();
66390     } catch (std::out_of_range& e) {
66391       {
66392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66393       };
66394     } catch (std::exception& e) {
66395       {
66396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66397       };
66398     } catch (Dali::DaliException e) {
66399       {
66400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66401       };
66402     } catch (...) {
66403       {
66404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66405       };
66406     }
66407   }
66408
66409 }
66410
66411
66412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
66413   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66414
66415   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66416   {
66417     try {
66418       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
66419     } catch (std::out_of_range& e) {
66420       {
66421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66422       };
66423     } catch (std::exception& e) {
66424       {
66425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66426       };
66427     } catch (Dali::DaliException e) {
66428       {
66429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66430       };
66431     } catch (...) {
66432       {
66433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66434       };
66435     }
66436   }
66437
66438 }
66439
66440
66441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
66442   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66443
66444   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66445   {
66446     try {
66447       (arg1)->OnKeyInputFocusLost();
66448     } catch (std::out_of_range& e) {
66449       {
66450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66451       };
66452     } catch (std::exception& e) {
66453       {
66454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66455       };
66456     } catch (Dali::DaliException e) {
66457       {
66458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66459       };
66460     } catch (...) {
66461       {
66462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66463       };
66464     }
66465   }
66466
66467 }
66468
66469
66470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
66471   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66472
66473   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66474   {
66475     try {
66476       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
66477     } catch (std::out_of_range& e) {
66478       {
66479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66480       };
66481     } catch (std::exception& e) {
66482       {
66483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66484       };
66485     } catch (Dali::DaliException e) {
66486       {
66487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66488       };
66489     } catch (...) {
66490       {
66491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66492       };
66493     }
66494   }
66495
66496 }
66497
66498
66499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66500   void * jresult ;
66501   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66502   Dali::Actor arg2 ;
66503   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66504   bool arg4 ;
66505   Dali::Actor *argp2 ;
66506   Dali::Actor result;
66507
66508   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66509   argp2 = (Dali::Actor *)jarg2;
66510   if (!argp2) {
66511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66512     return 0;
66513   }
66514   arg2 = *argp2;
66515   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66516   arg4 = jarg4 ? true : false;
66517   {
66518     try {
66519       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66520     } catch (std::out_of_range& e) {
66521       {
66522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66523       };
66524     } catch (std::exception& e) {
66525       {
66526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66527       };
66528     } catch (Dali::DaliException e) {
66529       {
66530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66531       };
66532     } catch (...) {
66533       {
66534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66535       };
66536     }
66537   }
66538
66539   jresult = new Dali::Actor((const Dali::Actor &)result);
66540   return jresult;
66541 }
66542
66543
66544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66545   void * jresult ;
66546   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66547   Dali::Actor arg2 ;
66548   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66549   bool arg4 ;
66550   Dali::Actor *argp2 ;
66551   Dali::Actor result;
66552
66553   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66554   argp2 = (Dali::Actor *)jarg2;
66555   if (!argp2) {
66556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66557     return 0;
66558   }
66559   arg2 = *argp2;
66560   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66561   arg4 = jarg4 ? true : false;
66562   {
66563     try {
66564       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66565     } catch (std::out_of_range& e) {
66566       {
66567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66568       };
66569     } catch (std::exception& e) {
66570       {
66571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66572       };
66573     } catch (Dali::DaliException e) {
66574       {
66575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66576       };
66577     } catch (...) {
66578       {
66579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66580       };
66581     }
66582   }
66583
66584   jresult = new Dali::Actor((const Dali::Actor &)result);
66585   return jresult;
66586 }
66587
66588
66589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
66590   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66591   Dali::Actor arg2 ;
66592   Dali::Actor *argp2 ;
66593
66594   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66595   argp2 = (Dali::Actor *)jarg2;
66596   if (!argp2) {
66597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66598     return ;
66599   }
66600   arg2 = *argp2;
66601   {
66602     try {
66603       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
66604     } catch (std::out_of_range& e) {
66605       {
66606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66607       };
66608     } catch (std::exception& e) {
66609       {
66610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66611       };
66612     } catch (Dali::DaliException e) {
66613       {
66614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66615       };
66616     } catch (...) {
66617       {
66618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66619       };
66620     }
66621   }
66622
66623 }
66624
66625
66626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66627   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66628   Dali::Actor arg2 ;
66629   Dali::Actor *argp2 ;
66630
66631   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66632   argp2 = (Dali::Actor *)jarg2;
66633   if (!argp2) {
66634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66635     return ;
66636   }
66637   arg2 = *argp2;
66638   {
66639     try {
66640       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
66641     } catch (std::out_of_range& e) {
66642       {
66643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66644       };
66645     } catch (std::exception& e) {
66646       {
66647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66648       };
66649     } catch (Dali::DaliException e) {
66650       {
66651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66652       };
66653     } catch (...) {
66654       {
66655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66656       };
66657     }
66658   }
66659
66660 }
66661
66662
66663 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
66664   unsigned int jresult ;
66665   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66666   bool result;
66667
66668   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66669   {
66670     try {
66671       result = (bool)(arg1)->OnKeyboardEnter();
66672     } catch (std::out_of_range& e) {
66673       {
66674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66675       };
66676     } catch (std::exception& e) {
66677       {
66678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66679       };
66680     } catch (Dali::DaliException e) {
66681       {
66682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66683       };
66684     } catch (...) {
66685       {
66686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66687       };
66688     }
66689   }
66690
66691   jresult = result;
66692   return jresult;
66693 }
66694
66695
66696 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
66697   unsigned int jresult ;
66698   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66699   bool result;
66700
66701   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66702   {
66703     try {
66704       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
66705     } catch (std::out_of_range& e) {
66706       {
66707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66708       };
66709     } catch (std::exception& e) {
66710       {
66711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66712       };
66713     } catch (Dali::DaliException e) {
66714       {
66715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66716       };
66717     } catch (...) {
66718       {
66719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66720       };
66721     }
66722   }
66723
66724   jresult = result;
66725   return jresult;
66726 }
66727
66728
66729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
66730   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66731   Dali::PinchGesture *arg2 = 0 ;
66732
66733   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66734   arg2 = (Dali::PinchGesture *)jarg2;
66735   if (!arg2) {
66736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66737     return ;
66738   }
66739   {
66740     try {
66741       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
66742     } catch (std::out_of_range& e) {
66743       {
66744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66745       };
66746     } catch (std::exception& e) {
66747       {
66748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66749       };
66750     } catch (Dali::DaliException e) {
66751       {
66752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66753       };
66754     } catch (...) {
66755       {
66756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66757       };
66758     }
66759   }
66760
66761 }
66762
66763
66764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66765   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66766   Dali::PinchGesture *arg2 = 0 ;
66767
66768   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66769   arg2 = (Dali::PinchGesture *)jarg2;
66770   if (!arg2) {
66771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66772     return ;
66773   }
66774   {
66775     try {
66776       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
66777     } catch (std::out_of_range& e) {
66778       {
66779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66780       };
66781     } catch (std::exception& e) {
66782       {
66783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66784       };
66785     } catch (Dali::DaliException e) {
66786       {
66787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66788       };
66789     } catch (...) {
66790       {
66791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66792       };
66793     }
66794   }
66795
66796 }
66797
66798
66799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
66800   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66801   Dali::PanGesture *arg2 = 0 ;
66802
66803   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66804   arg2 = (Dali::PanGesture *)jarg2;
66805   if (!arg2) {
66806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66807     return ;
66808   }
66809   {
66810     try {
66811       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
66812     } catch (std::out_of_range& e) {
66813       {
66814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66815       };
66816     } catch (std::exception& e) {
66817       {
66818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66819       };
66820     } catch (Dali::DaliException e) {
66821       {
66822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66823       };
66824     } catch (...) {
66825       {
66826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66827       };
66828     }
66829   }
66830
66831 }
66832
66833
66834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66835   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66836   Dali::PanGesture *arg2 = 0 ;
66837
66838   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66839   arg2 = (Dali::PanGesture *)jarg2;
66840   if (!arg2) {
66841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66842     return ;
66843   }
66844   {
66845     try {
66846       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
66847     } catch (std::out_of_range& e) {
66848       {
66849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66850       };
66851     } catch (std::exception& e) {
66852       {
66853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66854       };
66855     } catch (Dali::DaliException e) {
66856       {
66857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66858       };
66859     } catch (...) {
66860       {
66861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66862       };
66863     }
66864   }
66865
66866 }
66867
66868
66869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
66870   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66871   Dali::TapGesture *arg2 = 0 ;
66872
66873   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66874   arg2 = (Dali::TapGesture *)jarg2;
66875   if (!arg2) {
66876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66877     return ;
66878   }
66879   {
66880     try {
66881       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
66882     } catch (std::out_of_range& e) {
66883       {
66884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66885       };
66886     } catch (std::exception& e) {
66887       {
66888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66889       };
66890     } catch (Dali::DaliException e) {
66891       {
66892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66893       };
66894     } catch (...) {
66895       {
66896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66897       };
66898     }
66899   }
66900
66901 }
66902
66903
66904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66905   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66906   Dali::TapGesture *arg2 = 0 ;
66907
66908   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66909   arg2 = (Dali::TapGesture *)jarg2;
66910   if (!arg2) {
66911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66912     return ;
66913   }
66914   {
66915     try {
66916       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
66917     } catch (std::out_of_range& e) {
66918       {
66919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66920       };
66921     } catch (std::exception& e) {
66922       {
66923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66924       };
66925     } catch (Dali::DaliException e) {
66926       {
66927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66928       };
66929     } catch (...) {
66930       {
66931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66932       };
66933     }
66934   }
66935
66936 }
66937
66938
66939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
66940   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66941   Dali::LongPressGesture *arg2 = 0 ;
66942
66943   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66944   arg2 = (Dali::LongPressGesture *)jarg2;
66945   if (!arg2) {
66946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66947     return ;
66948   }
66949   {
66950     try {
66951       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
66952     } catch (std::out_of_range& e) {
66953       {
66954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66955       };
66956     } catch (std::exception& e) {
66957       {
66958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66959       };
66960     } catch (Dali::DaliException e) {
66961       {
66962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66963       };
66964     } catch (...) {
66965       {
66966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66967       };
66968     }
66969   }
66970
66971 }
66972
66973
66974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66975   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66976   Dali::LongPressGesture *arg2 = 0 ;
66977
66978   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66979   arg2 = (Dali::LongPressGesture *)jarg2;
66980   if (!arg2) {
66981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66982     return ;
66983   }
66984   {
66985     try {
66986       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
66987     } catch (std::out_of_range& e) {
66988       {
66989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66990       };
66991     } catch (std::exception& e) {
66992       {
66993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66994       };
66995     } catch (Dali::DaliException e) {
66996       {
66997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66998       };
66999     } catch (...) {
67000       {
67001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67002       };
67003     }
67004   }
67005
67006 }
67007
67008
67009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
67010   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67011   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67012   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67013
67014   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67015   arg2 = (Dali::SlotObserver *)jarg2;
67016   arg3 = (Dali::CallbackBase *)jarg3;
67017   {
67018     try {
67019       (arg1)->SignalConnected(arg2,arg3);
67020     } catch (std::out_of_range& e) {
67021       {
67022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67023       };
67024     } catch (std::exception& e) {
67025       {
67026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67027       };
67028     } catch (Dali::DaliException e) {
67029       {
67030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67031       };
67032     } catch (...) {
67033       {
67034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67035       };
67036     }
67037   }
67038
67039 }
67040
67041
67042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
67043   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67044   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67045   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67046
67047   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67048   arg2 = (Dali::SlotObserver *)jarg2;
67049   arg3 = (Dali::CallbackBase *)jarg3;
67050   {
67051     try {
67052       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
67053     } catch (std::out_of_range& e) {
67054       {
67055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67056       };
67057     } catch (std::exception& e) {
67058       {
67059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67060       };
67061     } catch (Dali::DaliException e) {
67062       {
67063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67064       };
67065     } catch (...) {
67066       {
67067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67068       };
67069     }
67070   }
67071
67072 }
67073
67074
67075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
67076   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67077   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67078   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67079
67080   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67081   arg2 = (Dali::SlotObserver *)jarg2;
67082   arg3 = (Dali::CallbackBase *)jarg3;
67083   {
67084     try {
67085       (arg1)->SignalDisconnected(arg2,arg3);
67086     } catch (std::out_of_range& e) {
67087       {
67088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67089       };
67090     } catch (std::exception& e) {
67091       {
67092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67093       };
67094     } catch (Dali::DaliException e) {
67095       {
67096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67097       };
67098     } catch (...) {
67099       {
67100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67101       };
67102     }
67103   }
67104
67105 }
67106
67107
67108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
67109   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67110   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67111   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67112
67113   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67114   arg2 = (Dali::SlotObserver *)jarg2;
67115   arg3 = (Dali::CallbackBase *)jarg3;
67116   {
67117     try {
67118       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
67119     } catch (std::out_of_range& e) {
67120       {
67121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67122       };
67123     } catch (std::exception& e) {
67124       {
67125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67126       };
67127     } catch (Dali::DaliException e) {
67128       {
67129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67130       };
67131     } catch (...) {
67132       {
67133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67134       };
67135     }
67136   }
67137
67138 }
67139
67140
67141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_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) {
67142   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
67143   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
67144   if (director) {
67145     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);
67146   }
67147 }
67148
67149
67150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
67151   void * jresult ;
67152   Dali::Toolkit::Control *arg1 = 0 ;
67153   Dali::Toolkit::Internal::Control *result = 0 ;
67154
67155   arg1 = (Dali::Toolkit::Control *)jarg1;
67156   if (!arg1) {
67157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67158     return 0;
67159   }
67160   {
67161     try {
67162       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
67163     } catch (std::out_of_range& e) {
67164       {
67165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67166       };
67167     } catch (std::exception& e) {
67168       {
67169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67170       };
67171     } catch (Dali::DaliException e) {
67172       {
67173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67174       };
67175     } catch (...) {
67176       {
67177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67178       };
67179     }
67180   }
67181
67182   jresult = (void *)result;
67183   return jresult;
67184 }
67185
67186
67187 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
67188   int jresult ;
67189   int result;
67190
67191   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
67192   jresult = (int)result;
67193   return jresult;
67194 }
67195
67196
67197 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
67198   int jresult ;
67199   int result;
67200
67201   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
67202   jresult = (int)result;
67203   return jresult;
67204 }
67205
67206
67207 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
67208   int jresult ;
67209   int result;
67210
67211   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
67212   jresult = (int)result;
67213   return jresult;
67214 }
67215
67216
67217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
67218   int jresult ;
67219   int result;
67220
67221   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
67222   jresult = (int)result;
67223   return jresult;
67224 }
67225
67226
67227 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
67228   int jresult ;
67229   int result;
67230
67231   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
67232   jresult = (int)result;
67233   return jresult;
67234 }
67235
67236 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
67237   int jresult ;
67238   int result;
67239
67240   result = (int)Dali::Toolkit::Control::Property::MARGIN;
67241   jresult = (int)result;
67242   return jresult;
67243 }
67244
67245
67246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
67247   int jresult ;
67248   int result;
67249
67250   result = (int)Dali::Toolkit::Control::Property::PADDING;
67251   jresult = (int)result;
67252   return jresult;
67253 }
67254
67255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
67256   void * jresult ;
67257   Dali::Toolkit::Control::Property *result = 0 ;
67258
67259   {
67260     try {
67261       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
67262     } catch (std::out_of_range& e) {
67263       {
67264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67265       };
67266     } catch (std::exception& e) {
67267       {
67268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67269       };
67270     } catch (Dali::DaliException e) {
67271       {
67272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67273       };
67274     } catch (...) {
67275       {
67276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67277       };
67278     }
67279   }
67280
67281   jresult = (void *)result;
67282   return jresult;
67283 }
67284
67285
67286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
67287   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
67288
67289   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
67290   {
67291     try {
67292       delete arg1;
67293     } catch (std::out_of_range& e) {
67294       {
67295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67296       };
67297     } catch (std::exception& e) {
67298       {
67299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67300       };
67301     } catch (Dali::DaliException e) {
67302       {
67303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67304       };
67305     } catch (...) {
67306       {
67307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67308       };
67309     }
67310   }
67311
67312 }
67313
67314
67315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
67316   void * jresult ;
67317   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
67318
67319   {
67320     try {
67321       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
67322     } catch (std::out_of_range& e) {
67323       {
67324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67325       };
67326     } catch (std::exception& e) {
67327       {
67328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67329       };
67330     } catch (Dali::DaliException e) {
67331       {
67332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67333       };
67334     } catch (...) {
67335       {
67336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67337       };
67338     }
67339   }
67340
67341   jresult = (void *)result;
67342   return jresult;
67343 }
67344
67345
67346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
67347   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
67348
67349   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
67350   {
67351     try {
67352       delete arg1;
67353     } catch (std::out_of_range& e) {
67354       {
67355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67356       };
67357     } catch (std::exception& e) {
67358       {
67359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67360       };
67361     } catch (Dali::DaliException e) {
67362       {
67363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67364       };
67365     } catch (...) {
67366       {
67367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67368       };
67369     }
67370   }
67371
67372 }
67373
67374
67375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
67376   void * jresult ;
67377   Dali::Toolkit::Control result;
67378
67379   {
67380     try {
67381       result = Dali::Toolkit::Control::New();
67382     } catch (std::out_of_range& e) {
67383       {
67384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67385       };
67386     } catch (std::exception& e) {
67387       {
67388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67389       };
67390     } catch (Dali::DaliException e) {
67391       {
67392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67393       };
67394     } catch (...) {
67395       {
67396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67397       };
67398     }
67399   }
67400
67401   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67402   return jresult;
67403 }
67404
67405
67406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
67407   void * jresult ;
67408   Dali::Toolkit::Control *result = 0 ;
67409
67410   {
67411     try {
67412       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
67413     } catch (std::out_of_range& e) {
67414       {
67415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67416       };
67417     } catch (std::exception& e) {
67418       {
67419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67420       };
67421     } catch (Dali::DaliException e) {
67422       {
67423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67424       };
67425     } catch (...) {
67426       {
67427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67428       };
67429     }
67430   }
67431
67432   jresult = (void *)result;
67433   return jresult;
67434 }
67435
67436
67437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
67438   void * jresult ;
67439   Dali::Toolkit::Control *arg1 = 0 ;
67440   Dali::Toolkit::Control *result = 0 ;
67441
67442   arg1 = (Dali::Toolkit::Control *)jarg1;
67443   if (!arg1) {
67444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67445     return 0;
67446   }
67447   {
67448     try {
67449       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
67450     } catch (std::out_of_range& e) {
67451       {
67452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67453       };
67454     } catch (std::exception& e) {
67455       {
67456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67457       };
67458     } catch (Dali::DaliException e) {
67459       {
67460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67461       };
67462     } catch (...) {
67463       {
67464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67465       };
67466     }
67467   }
67468
67469   jresult = (void *)result;
67470   return jresult;
67471 }
67472
67473
67474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
67475   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67476
67477   arg1 = (Dali::Toolkit::Control *)jarg1;
67478   {
67479     try {
67480       delete arg1;
67481     } catch (std::out_of_range& e) {
67482       {
67483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67484       };
67485     } catch (std::exception& e) {
67486       {
67487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67488       };
67489     } catch (Dali::DaliException e) {
67490       {
67491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67492       };
67493     } catch (...) {
67494       {
67495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67496       };
67497     }
67498   }
67499
67500 }
67501
67502
67503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
67504   void * jresult ;
67505   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67506   Dali::Toolkit::Control *arg2 = 0 ;
67507   Dali::Toolkit::Control *result = 0 ;
67508
67509   arg1 = (Dali::Toolkit::Control *)jarg1;
67510   arg2 = (Dali::Toolkit::Control *)jarg2;
67511   if (!arg2) {
67512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67513     return 0;
67514   }
67515   {
67516     try {
67517       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
67518     } catch (std::out_of_range& e) {
67519       {
67520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67521       };
67522     } catch (std::exception& e) {
67523       {
67524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67525       };
67526     } catch (Dali::DaliException e) {
67527       {
67528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67529       };
67530     } catch (...) {
67531       {
67532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67533       };
67534     }
67535   }
67536
67537   jresult = (void *)result;
67538   return jresult;
67539 }
67540
67541
67542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
67543   void * jresult ;
67544   Dali::BaseHandle arg1 ;
67545   Dali::BaseHandle *argp1 ;
67546   Dali::Toolkit::Control result;
67547
67548   argp1 = (Dali::BaseHandle *)jarg1;
67549   if (!argp1) {
67550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67551     return 0;
67552   }
67553   arg1 = *argp1;
67554   {
67555     try {
67556       result = Dali::Toolkit::Control::DownCast(arg1);
67557     } catch (std::out_of_range& e) {
67558       {
67559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67560       };
67561     } catch (std::exception& e) {
67562       {
67563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67564       };
67565     } catch (Dali::DaliException e) {
67566       {
67567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67568       };
67569     } catch (...) {
67570       {
67571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67572       };
67573     }
67574   }
67575
67576   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67577   return jresult;
67578 }
67579
67580
67581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
67582   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67583
67584   arg1 = (Dali::Toolkit::Control *)jarg1;
67585   {
67586     try {
67587       (arg1)->SetKeyInputFocus();
67588     } catch (std::out_of_range& e) {
67589       {
67590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67591       };
67592     } catch (std::exception& e) {
67593       {
67594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67595       };
67596     } catch (Dali::DaliException e) {
67597       {
67598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67599       };
67600     } catch (...) {
67601       {
67602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67603       };
67604     }
67605   }
67606
67607 }
67608
67609
67610 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
67611   unsigned int jresult ;
67612   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67613   bool result;
67614
67615   arg1 = (Dali::Toolkit::Control *)jarg1;
67616   {
67617     try {
67618       result = (bool)(arg1)->HasKeyInputFocus();
67619     } catch (std::out_of_range& e) {
67620       {
67621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67622       };
67623     } catch (std::exception& e) {
67624       {
67625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67626       };
67627     } catch (Dali::DaliException e) {
67628       {
67629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67630       };
67631     } catch (...) {
67632       {
67633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67634       };
67635     }
67636   }
67637
67638   jresult = result;
67639   return jresult;
67640 }
67641
67642
67643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
67644   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67645
67646   arg1 = (Dali::Toolkit::Control *)jarg1;
67647   {
67648     try {
67649       (arg1)->ClearKeyInputFocus();
67650     } catch (std::out_of_range& e) {
67651       {
67652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67653       };
67654     } catch (std::exception& e) {
67655       {
67656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67657       };
67658     } catch (Dali::DaliException e) {
67659       {
67660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67661       };
67662     } catch (...) {
67663       {
67664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67665       };
67666     }
67667   }
67668
67669 }
67670
67671
67672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
67673   void * jresult ;
67674   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67675   Dali::PinchGestureDetector result;
67676
67677   arg1 = (Dali::Toolkit::Control *)jarg1;
67678   {
67679     try {
67680       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
67681     } catch (std::out_of_range& e) {
67682       {
67683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67684       };
67685     } catch (std::exception& e) {
67686       {
67687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67688       };
67689     } catch (Dali::DaliException e) {
67690       {
67691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67692       };
67693     } catch (...) {
67694       {
67695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67696       };
67697     }
67698   }
67699
67700   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
67701   return jresult;
67702 }
67703
67704
67705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
67706   void * jresult ;
67707   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67708   Dali::PanGestureDetector result;
67709
67710   arg1 = (Dali::Toolkit::Control *)jarg1;
67711   {
67712     try {
67713       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
67714     } catch (std::out_of_range& e) {
67715       {
67716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67717       };
67718     } catch (std::exception& e) {
67719       {
67720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67721       };
67722     } catch (Dali::DaliException e) {
67723       {
67724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67725       };
67726     } catch (...) {
67727       {
67728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67729       };
67730     }
67731   }
67732
67733   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
67734   return jresult;
67735 }
67736
67737
67738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
67739   void * jresult ;
67740   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67741   Dali::TapGestureDetector result;
67742
67743   arg1 = (Dali::Toolkit::Control *)jarg1;
67744   {
67745     try {
67746       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
67747     } catch (std::out_of_range& e) {
67748       {
67749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67750       };
67751     } catch (std::exception& e) {
67752       {
67753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67754       };
67755     } catch (Dali::DaliException e) {
67756       {
67757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67758       };
67759     } catch (...) {
67760       {
67761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67762       };
67763     }
67764   }
67765
67766   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
67767   return jresult;
67768 }
67769
67770
67771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
67772   void * jresult ;
67773   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67774   Dali::LongPressGestureDetector result;
67775
67776   arg1 = (Dali::Toolkit::Control *)jarg1;
67777   {
67778     try {
67779       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
67780     } catch (std::out_of_range& e) {
67781       {
67782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67783       };
67784     } catch (std::exception& e) {
67785       {
67786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67787       };
67788     } catch (Dali::DaliException e) {
67789       {
67790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67791       };
67792     } catch (...) {
67793       {
67794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67795       };
67796     }
67797   }
67798
67799   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
67800   return jresult;
67801 }
67802
67803
67804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
67805   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67806   std::string *arg2 = 0 ;
67807
67808   arg1 = (Dali::Toolkit::Control *)jarg1;
67809   if (!jarg2) {
67810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67811     return ;
67812   }
67813   std::string arg2_str(jarg2);
67814   arg2 = &arg2_str;
67815   {
67816     try {
67817       (arg1)->SetStyleName((std::string const &)*arg2);
67818     } catch (std::out_of_range& e) {
67819       {
67820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67821       };
67822     } catch (std::exception& e) {
67823       {
67824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67825       };
67826     } catch (Dali::DaliException e) {
67827       {
67828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67829       };
67830     } catch (...) {
67831       {
67832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67833       };
67834     }
67835   }
67836
67837
67838   //argout typemap for const std::string&
67839
67840 }
67841
67842
67843 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
67844   char * jresult ;
67845   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67846   std::string *result = 0 ;
67847
67848   arg1 = (Dali::Toolkit::Control *)jarg1;
67849   {
67850     try {
67851       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
67852     } catch (std::out_of_range& e) {
67853       {
67854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67855       };
67856     } catch (std::exception& e) {
67857       {
67858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67859       };
67860     } catch (Dali::DaliException e) {
67861       {
67862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67863       };
67864     } catch (...) {
67865       {
67866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67867       };
67868     }
67869   }
67870
67871   jresult = SWIG_csharp_string_callback(result->c_str());
67872   return jresult;
67873 }
67874
67875
67876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
67877   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67878   Dali::Vector4 *arg2 = 0 ;
67879
67880   arg1 = (Dali::Toolkit::Control *)jarg1;
67881   arg2 = (Dali::Vector4 *)jarg2;
67882   if (!arg2) {
67883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
67884     return ;
67885   }
67886   {
67887     try {
67888       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
67889     } catch (std::out_of_range& e) {
67890       {
67891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67892       };
67893     } catch (std::exception& e) {
67894       {
67895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67896       };
67897     } catch (Dali::DaliException e) {
67898       {
67899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67900       };
67901     } catch (...) {
67902       {
67903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67904       };
67905     }
67906   }
67907
67908 }
67909
67910
67911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
67912   void * jresult ;
67913   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67914   Dali::Vector4 result;
67915
67916   arg1 = (Dali::Toolkit::Control *)jarg1;
67917   {
67918     try {
67919       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
67920     } catch (std::out_of_range& e) {
67921       {
67922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67923       };
67924     } catch (std::exception& e) {
67925       {
67926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67927       };
67928     } catch (Dali::DaliException e) {
67929       {
67930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67931       };
67932     } catch (...) {
67933       {
67934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67935       };
67936     }
67937   }
67938
67939   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
67940   return jresult;
67941 }
67942
67943
67944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
67945   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67946   Dali::Image arg2 ;
67947   Dali::Image *argp2 ;
67948
67949   arg1 = (Dali::Toolkit::Control *)jarg1;
67950   argp2 = (Dali::Image *)jarg2;
67951   if (!argp2) {
67952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
67953     return ;
67954   }
67955   arg2 = *argp2;
67956   {
67957     try {
67958       (arg1)->SetBackgroundImage(arg2);
67959     } catch (std::out_of_range& e) {
67960       {
67961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67962       };
67963     } catch (std::exception& e) {
67964       {
67965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67966       };
67967     } catch (Dali::DaliException e) {
67968       {
67969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67970       };
67971     } catch (...) {
67972       {
67973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67974       };
67975     }
67976   }
67977
67978 }
67979
67980
67981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
67982   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67983
67984   arg1 = (Dali::Toolkit::Control *)jarg1;
67985   {
67986     try {
67987       (arg1)->ClearBackground();
67988     } catch (std::out_of_range& e) {
67989       {
67990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67991       };
67992     } catch (std::exception& e) {
67993       {
67994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67995       };
67996     } catch (Dali::DaliException e) {
67997       {
67998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67999       };
68000     } catch (...) {
68001       {
68002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68003       };
68004     }
68005   }
68006
68007 }
68008
68009
68010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
68011   void * jresult ;
68012   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68013   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
68014
68015   arg1 = (Dali::Toolkit::Control *)jarg1;
68016   {
68017     try {
68018       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
68019     } catch (std::out_of_range& e) {
68020       {
68021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68022       };
68023     } catch (std::exception& e) {
68024       {
68025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68026       };
68027     } catch (Dali::DaliException e) {
68028       {
68029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68030       };
68031     } catch (...) {
68032       {
68033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68034       };
68035     }
68036   }
68037
68038   jresult = (void *)result;
68039   return jresult;
68040 }
68041
68042
68043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
68044   void * jresult ;
68045   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68046   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
68047
68048   arg1 = (Dali::Toolkit::Control *)jarg1;
68049   {
68050     try {
68051       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
68052     } catch (std::out_of_range& e) {
68053       {
68054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68055       };
68056     } catch (std::exception& e) {
68057       {
68058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68059       };
68060     } catch (Dali::DaliException e) {
68061       {
68062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68063       };
68064     } catch (...) {
68065       {
68066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68067       };
68068     }
68069   }
68070
68071   jresult = (void *)result;
68072   return jresult;
68073 }
68074
68075
68076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
68077   void * jresult ;
68078   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68079   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
68080
68081   arg1 = (Dali::Toolkit::Control *)jarg1;
68082   {
68083     try {
68084       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
68085     } catch (std::out_of_range& e) {
68086       {
68087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68088       };
68089     } catch (std::exception& e) {
68090       {
68091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68092       };
68093     } catch (Dali::DaliException e) {
68094       {
68095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68096       };
68097     } catch (...) {
68098       {
68099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68100       };
68101     }
68102   }
68103
68104   jresult = (void *)result;
68105   return jresult;
68106 }
68107
68108
68109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
68110   void * jresult ;
68111   Dali::Toolkit::Internal::Control *arg1 = 0 ;
68112   Dali::Toolkit::Control *result = 0 ;
68113
68114   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
68115   if (!arg1) {
68116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68117     return 0;
68118   }
68119   {
68120     try {
68121       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
68122     } catch (std::out_of_range& e) {
68123       {
68124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68125       };
68126     } catch (std::exception& e) {
68127       {
68128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68129       };
68130     } catch (Dali::DaliException e) {
68131       {
68132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68133       };
68134     } catch (...) {
68135       {
68136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68137       };
68138     }
68139   }
68140
68141   jresult = (void *)result;
68142   return jresult;
68143 }
68144
68145 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
68146 {
68147   int jresult;
68148   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68149   arg1 = (Dali::Toolkit::Control *)jarg1;
68150
68151   if (!arg1) {
68152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68153     return 0;
68154   }
68155
68156   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
68157
68158   Dali::Property::Index arg2 = 0 ;
68159   arg2 = (Dali::Property::Index)jarg2;
68160
68161   Toolkit::Visual::ResourceStatus result;
68162   {
68163     try {
68164       result = DevelControl::GetVisualResourceStatus(controlImpl, arg2);
68165     } catch (std::out_of_range& e) {
68166       {
68167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68168       };
68169     } catch (std::exception& e) {
68170       {
68171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68172       };
68173     } catch (...) {
68174       {
68175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68176       };
68177     }
68178   }
68179   jresult = (int)(result);
68180   return jresult;
68181 }
68182
68183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
68184 {
68185   void * jresult;
68186   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68187   arg1 = (Dali::Toolkit::Control *)jarg1;
68188
68189   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
68190
68191   Dali::Toolkit::TransitionData *arg2 = 0 ;
68192   Dali::Animation result;
68193
68194   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
68195   if (!arg2) {
68196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
68197     return 0;
68198   }
68199   {
68200     try {
68201       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
68202     } catch (std::out_of_range& e) {
68203       {
68204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68205       };
68206     } catch (std::exception& e) {
68207       {
68208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68209       };
68210     } catch (Dali::DaliException e) {
68211       {
68212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68213       };
68214     } catch (...) {
68215       {
68216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68217       };
68218     }
68219   }
68220
68221   jresult = new Dali::Animation((const Dali::Animation &)result);
68222   return jresult;
68223 }
68224
68225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
68226 {
68227   Dali::Toolkit::Control arg1;
68228   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
68229
68230   if (!argp1) {
68231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68232   }
68233   arg1 = *argp1;
68234
68235   Dali::Property::Index arg2 = 0 ;
68236   arg2 = (Dali::Property::Index)jarg2;
68237
68238   Dali::Property::Index arg3 = 0 ;
68239   arg3 = (Dali::Property::Index)jarg3;
68240
68241   Dali::Property::Value arg4;
68242   arg4 = (Dali::Property::Value *)jarg4;
68243
68244   {
68245     try {
68246       DevelControl::DoAction(arg1, arg2, arg3, arg4);
68247     } catch (std::out_of_range& e) {
68248       {
68249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68250       };
68251     } catch (std::exception& e) {
68252       {
68253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68254       };
68255     } catch (...) {
68256       {
68257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68258       };
68259     }
68260   }
68261
68262
68263 }
68264
68265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
68266   void * jresult ;
68267   Dali::Toolkit::Control *arg1 = 0 ;
68268   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
68269
68270   arg1 = (Dali::Toolkit::Control *)jarg1;
68271   if (!arg1) {
68272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68273     return 0;
68274   }
68275   {
68276     try {
68277       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
68278     } catch (std::out_of_range& e) {
68279       {
68280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68281       };
68282     } catch (std::exception& e) {
68283       {
68284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68285       };
68286     } catch (Dali::DaliException e) {
68287       {
68288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68289       };
68290     } catch (...) {
68291       {
68292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68293       };
68294     }
68295   }
68296
68297   jresult = (void *)result;
68298   return jresult;
68299 }
68300
68301
68302 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
68303   unsigned int jresult ;
68304   Dali::Toolkit::Control *arg1 = 0 ;
68305   bool result;
68306
68307   arg1 = (Dali::Toolkit::Control *)jarg1;
68308   if (!arg1) {
68309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
68310     return 0;
68311   }
68312   {
68313     try {
68314       result = (bool)arg1->IsResourceReady();
68315     } catch (std::out_of_range& e) {
68316       {
68317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68318       };
68319     } catch (std::exception& e) {
68320       {
68321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68322       };
68323     } catch (Dali::DaliException e) {
68324       {
68325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68326       };
68327     } catch (...) {
68328       {
68329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68330       };
68331     }
68332   }
68333
68334   jresult = result;
68335   return jresult;
68336 }
68337
68338
68339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
68340   void * jresult ;
68341   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
68342
68343   {
68344     try {
68345       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
68346     } catch (std::out_of_range& e) {
68347       {
68348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68349       };
68350     } catch (std::exception& e) {
68351       {
68352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68353       };
68354     } catch (Dali::DaliException e) {
68355       {
68356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68357       };
68358     } catch (...) {
68359       {
68360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68361       };
68362     }
68363   }
68364
68365   jresult = (void *)result;
68366   return jresult;
68367 }
68368
68369
68370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
68371   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68372
68373   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68374   {
68375     try {
68376       delete arg1;
68377     } catch (std::out_of_range& e) {
68378       {
68379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68380       };
68381     } catch (std::exception& e) {
68382       {
68383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68384       };
68385     } catch (Dali::DaliException e) {
68386       {
68387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68388       };
68389     } catch (...) {
68390       {
68391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68392       };
68393     }
68394   }
68395
68396 }
68397
68398
68399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
68400   void * jresult ;
68401   Dali::Toolkit::KeyInputFocusManager result;
68402
68403   {
68404     try {
68405       result = Dali::Toolkit::KeyInputFocusManager::Get();
68406     } catch (std::out_of_range& e) {
68407       {
68408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68409       };
68410     } catch (std::exception& e) {
68411       {
68412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68413       };
68414     } catch (Dali::DaliException e) {
68415       {
68416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68417       };
68418     } catch (...) {
68419       {
68420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68421       };
68422     }
68423   }
68424
68425   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
68426   return jresult;
68427 }
68428
68429
68430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
68431   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68432   Dali::Toolkit::Control arg2 ;
68433   Dali::Toolkit::Control *argp2 ;
68434
68435   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68436   argp2 = (Dali::Toolkit::Control *)jarg2;
68437   if (!argp2) {
68438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68439     return ;
68440   }
68441   arg2 = *argp2;
68442   {
68443     try {
68444       (arg1)->SetFocus(arg2);
68445     } catch (std::out_of_range& e) {
68446       {
68447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68448       };
68449     } catch (std::exception& e) {
68450       {
68451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68452       };
68453     } catch (Dali::DaliException e) {
68454       {
68455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68456       };
68457     } catch (...) {
68458       {
68459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68460       };
68461     }
68462   }
68463
68464 }
68465
68466
68467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
68468   void * jresult ;
68469   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68470   Dali::Toolkit::Control result;
68471
68472   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68473   {
68474     try {
68475       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
68476     } catch (std::out_of_range& e) {
68477       {
68478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68479       };
68480     } catch (std::exception& e) {
68481       {
68482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68483       };
68484     } catch (Dali::DaliException e) {
68485       {
68486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68487       };
68488     } catch (...) {
68489       {
68490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68491       };
68492     }
68493   }
68494
68495   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
68496   return jresult;
68497 }
68498
68499
68500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
68501   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68502   Dali::Toolkit::Control arg2 ;
68503   Dali::Toolkit::Control *argp2 ;
68504
68505   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68506   argp2 = (Dali::Toolkit::Control *)jarg2;
68507   if (!argp2) {
68508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68509     return ;
68510   }
68511   arg2 = *argp2;
68512   {
68513     try {
68514       (arg1)->RemoveFocus(arg2);
68515     } catch (std::out_of_range& e) {
68516       {
68517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68518       };
68519     } catch (std::exception& e) {
68520       {
68521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68522       };
68523     } catch (Dali::DaliException e) {
68524       {
68525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68526       };
68527     } catch (...) {
68528       {
68529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68530       };
68531     }
68532   }
68533
68534 }
68535
68536
68537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
68538   void * jresult ;
68539   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68540   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
68541
68542   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68543   {
68544     try {
68545       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
68546     } catch (std::out_of_range& e) {
68547       {
68548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68549       };
68550     } catch (std::exception& e) {
68551       {
68552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68553       };
68554     } catch (Dali::DaliException e) {
68555       {
68556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68557       };
68558     } catch (...) {
68559       {
68560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68561       };
68562     }
68563   }
68564
68565   jresult = (void *)result;
68566   return jresult;
68567 }
68568
68569
68570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
68571   void * jresult ;
68572   Dali::Toolkit::Alignment::Padding *result = 0 ;
68573
68574   {
68575     try {
68576       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
68577     } catch (std::out_of_range& e) {
68578       {
68579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68580       };
68581     } catch (std::exception& e) {
68582       {
68583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68584       };
68585     } catch (Dali::DaliException e) {
68586       {
68587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68588       };
68589     } catch (...) {
68590       {
68591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68592       };
68593     }
68594   }
68595
68596   jresult = (void *)result;
68597   return jresult;
68598 }
68599
68600
68601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
68602   void * jresult ;
68603   float arg1 ;
68604   float arg2 ;
68605   float arg3 ;
68606   float arg4 ;
68607   Dali::Toolkit::Alignment::Padding *result = 0 ;
68608
68609   arg1 = (float)jarg1;
68610   arg2 = (float)jarg2;
68611   arg3 = (float)jarg3;
68612   arg4 = (float)jarg4;
68613   {
68614     try {
68615       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
68616     } catch (std::out_of_range& e) {
68617       {
68618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68619       };
68620     } catch (std::exception& e) {
68621       {
68622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68623       };
68624     } catch (Dali::DaliException e) {
68625       {
68626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68627       };
68628     } catch (...) {
68629       {
68630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68631       };
68632     }
68633   }
68634
68635   jresult = (void *)result;
68636   return jresult;
68637 }
68638
68639
68640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
68641   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68642   float arg2 ;
68643
68644   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68645   arg2 = (float)jarg2;
68646   if (arg1) (arg1)->left = arg2;
68647 }
68648
68649
68650 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
68651   float jresult ;
68652   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68653   float result;
68654
68655   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68656   result = (float) ((arg1)->left);
68657   jresult = result;
68658   return jresult;
68659 }
68660
68661
68662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
68663   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68664   float arg2 ;
68665
68666   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68667   arg2 = (float)jarg2;
68668   if (arg1) (arg1)->right = arg2;
68669 }
68670
68671
68672 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
68673   float jresult ;
68674   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68675   float result;
68676
68677   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68678   result = (float) ((arg1)->right);
68679   jresult = result;
68680   return jresult;
68681 }
68682
68683
68684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
68685   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68686   float arg2 ;
68687
68688   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68689   arg2 = (float)jarg2;
68690   if (arg1) (arg1)->top = arg2;
68691 }
68692
68693
68694 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
68695   float jresult ;
68696   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68697   float result;
68698
68699   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68700   result = (float) ((arg1)->top);
68701   jresult = result;
68702   return jresult;
68703 }
68704
68705
68706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
68707   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68708   float arg2 ;
68709
68710   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68711   arg2 = (float)jarg2;
68712   if (arg1) (arg1)->bottom = arg2;
68713 }
68714
68715
68716 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
68717   float jresult ;
68718   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68719   float result;
68720
68721   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68722   result = (float) ((arg1)->bottom);
68723   jresult = result;
68724   return jresult;
68725 }
68726
68727
68728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
68729   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68730
68731   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68732   {
68733     try {
68734       delete arg1;
68735     } catch (std::out_of_range& e) {
68736       {
68737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68738       };
68739     } catch (std::exception& e) {
68740       {
68741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68742       };
68743     } catch (Dali::DaliException e) {
68744       {
68745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68746       };
68747     } catch (...) {
68748       {
68749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68750       };
68751     }
68752   }
68753
68754 }
68755
68756
68757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
68758   void * jresult ;
68759   Dali::Toolkit::Alignment *result = 0 ;
68760
68761   {
68762     try {
68763       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
68764     } catch (std::out_of_range& e) {
68765       {
68766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68767       };
68768     } catch (std::exception& e) {
68769       {
68770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68771       };
68772     } catch (Dali::DaliException e) {
68773       {
68774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68775       };
68776     } catch (...) {
68777       {
68778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68779       };
68780     }
68781   }
68782
68783   jresult = (void *)result;
68784   return jresult;
68785 }
68786
68787
68788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
68789   void * jresult ;
68790   Dali::Toolkit::Alignment::Type arg1 ;
68791   Dali::Toolkit::Alignment::Type arg2 ;
68792   Dali::Toolkit::Alignment result;
68793
68794   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68795   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68796   {
68797     try {
68798       result = Dali::Toolkit::Alignment::New(arg1,arg2);
68799     } catch (std::out_of_range& e) {
68800       {
68801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68802       };
68803     } catch (std::exception& e) {
68804       {
68805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68806       };
68807     } catch (Dali::DaliException e) {
68808       {
68809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68810       };
68811     } catch (...) {
68812       {
68813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68814       };
68815     }
68816   }
68817
68818   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68819   return jresult;
68820 }
68821
68822
68823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
68824   void * jresult ;
68825   Dali::Toolkit::Alignment::Type arg1 ;
68826   Dali::Toolkit::Alignment result;
68827
68828   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68829   {
68830     try {
68831       result = Dali::Toolkit::Alignment::New(arg1);
68832     } catch (std::out_of_range& e) {
68833       {
68834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68835       };
68836     } catch (std::exception& e) {
68837       {
68838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68839       };
68840     } catch (Dali::DaliException e) {
68841       {
68842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68843       };
68844     } catch (...) {
68845       {
68846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68847       };
68848     }
68849   }
68850
68851   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68852   return jresult;
68853 }
68854
68855
68856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
68857   void * jresult ;
68858   Dali::Toolkit::Alignment result;
68859
68860   {
68861     try {
68862       result = Dali::Toolkit::Alignment::New();
68863     } catch (std::out_of_range& e) {
68864       {
68865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68866       };
68867     } catch (std::exception& e) {
68868       {
68869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68870       };
68871     } catch (Dali::DaliException e) {
68872       {
68873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68874       };
68875     } catch (...) {
68876       {
68877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68878       };
68879     }
68880   }
68881
68882   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68883   return jresult;
68884 }
68885
68886
68887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
68888   void * jresult ;
68889   Dali::Toolkit::Alignment *arg1 = 0 ;
68890   Dali::Toolkit::Alignment *result = 0 ;
68891
68892   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68893   if (!arg1) {
68894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
68895     return 0;
68896   }
68897   {
68898     try {
68899       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
68900     } catch (std::out_of_range& e) {
68901       {
68902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68903       };
68904     } catch (std::exception& e) {
68905       {
68906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68907       };
68908     } catch (Dali::DaliException e) {
68909       {
68910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68911       };
68912     } catch (...) {
68913       {
68914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68915       };
68916     }
68917   }
68918
68919   jresult = (void *)result;
68920   return jresult;
68921 }
68922
68923
68924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
68925   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68926
68927   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68928   {
68929     try {
68930       delete arg1;
68931     } catch (std::out_of_range& e) {
68932       {
68933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68934       };
68935     } catch (std::exception& e) {
68936       {
68937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68938       };
68939     } catch (Dali::DaliException e) {
68940       {
68941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68942       };
68943     } catch (...) {
68944       {
68945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68946       };
68947     }
68948   }
68949
68950 }
68951
68952
68953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
68954   void * jresult ;
68955   Dali::BaseHandle arg1 ;
68956   Dali::BaseHandle *argp1 ;
68957   Dali::Toolkit::Alignment result;
68958
68959   argp1 = (Dali::BaseHandle *)jarg1;
68960   if (!argp1) {
68961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68962     return 0;
68963   }
68964   arg1 = *argp1;
68965   {
68966     try {
68967       result = Dali::Toolkit::Alignment::DownCast(arg1);
68968     } catch (std::out_of_range& e) {
68969       {
68970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68971       };
68972     } catch (std::exception& e) {
68973       {
68974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68975       };
68976     } catch (Dali::DaliException e) {
68977       {
68978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68979       };
68980     } catch (...) {
68981       {
68982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68983       };
68984     }
68985   }
68986
68987   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68988   return jresult;
68989 }
68990
68991
68992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
68993   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68994   Dali::Toolkit::Alignment::Type arg2 ;
68995
68996   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68997   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68998   {
68999     try {
69000       (arg1)->SetAlignmentType(arg2);
69001     } catch (std::out_of_range& e) {
69002       {
69003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69004       };
69005     } catch (std::exception& e) {
69006       {
69007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69008       };
69009     } catch (Dali::DaliException e) {
69010       {
69011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69012       };
69013     } catch (...) {
69014       {
69015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69016       };
69017     }
69018   }
69019
69020 }
69021
69022
69023 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
69024   int jresult ;
69025   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69026   Dali::Toolkit::Alignment::Type result;
69027
69028   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69029   {
69030     try {
69031       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
69032     } catch (std::out_of_range& e) {
69033       {
69034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69035       };
69036     } catch (std::exception& e) {
69037       {
69038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69039       };
69040     } catch (Dali::DaliException e) {
69041       {
69042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69043       };
69044     } catch (...) {
69045       {
69046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69047       };
69048     }
69049   }
69050
69051   jresult = (int)result;
69052   return jresult;
69053 }
69054
69055
69056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
69057   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69058   Dali::Toolkit::Alignment::Scaling arg2 ;
69059
69060   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69061   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
69062   {
69063     try {
69064       (arg1)->SetScaling(arg2);
69065     } catch (std::out_of_range& e) {
69066       {
69067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69068       };
69069     } catch (std::exception& e) {
69070       {
69071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69072       };
69073     } catch (Dali::DaliException e) {
69074       {
69075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69076       };
69077     } catch (...) {
69078       {
69079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69080       };
69081     }
69082   }
69083
69084 }
69085
69086
69087 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
69088   int jresult ;
69089   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69090   Dali::Toolkit::Alignment::Scaling result;
69091
69092   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69093   {
69094     try {
69095       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
69096     } catch (std::out_of_range& e) {
69097       {
69098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69099       };
69100     } catch (std::exception& e) {
69101       {
69102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69103       };
69104     } catch (Dali::DaliException e) {
69105       {
69106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69107       };
69108     } catch (...) {
69109       {
69110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69111       };
69112     }
69113   }
69114
69115   jresult = (int)result;
69116   return jresult;
69117 }
69118
69119
69120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
69121   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69122   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
69123
69124   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69125   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
69126   if (!arg2) {
69127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
69128     return ;
69129   }
69130   {
69131     try {
69132       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
69133     } catch (std::out_of_range& e) {
69134       {
69135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69136       };
69137     } catch (std::exception& e) {
69138       {
69139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69140       };
69141     } catch (Dali::DaliException e) {
69142       {
69143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69144       };
69145     } catch (...) {
69146       {
69147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69148       };
69149     }
69150   }
69151
69152 }
69153
69154
69155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
69156   void * jresult ;
69157   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69158   Dali::Toolkit::Alignment::Padding *result = 0 ;
69159
69160   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69161   {
69162     try {
69163       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
69164     } catch (std::out_of_range& e) {
69165       {
69166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69167       };
69168     } catch (std::exception& e) {
69169       {
69170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69171       };
69172     } catch (Dali::DaliException e) {
69173       {
69174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69175       };
69176     } catch (...) {
69177       {
69178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69179       };
69180     }
69181   }
69182
69183   jresult = (void *)result;
69184   return jresult;
69185 }
69186
69187
69188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
69189   void * jresult ;
69190   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69191   Dali::Toolkit::Alignment *arg2 = 0 ;
69192   Dali::Toolkit::Alignment *result = 0 ;
69193
69194   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69195   arg2 = (Dali::Toolkit::Alignment *)jarg2;
69196   if (!arg2) {
69197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
69198     return 0;
69199   }
69200   {
69201     try {
69202       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
69203     } catch (std::out_of_range& e) {
69204       {
69205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69206       };
69207     } catch (std::exception& e) {
69208       {
69209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69210       };
69211     } catch (Dali::DaliException e) {
69212       {
69213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69214       };
69215     } catch (...) {
69216       {
69217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69218       };
69219     }
69220   }
69221
69222   jresult = (void *)result;
69223   return jresult;
69224 }
69225
69226
69227 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
69228   int jresult ;
69229   int result;
69230
69231   result = (int)Dali::Toolkit::Button::Property::DISABLED;
69232   jresult = (int)result;
69233   return jresult;
69234 }
69235
69236
69237 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
69238   int jresult ;
69239   int result;
69240
69241   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
69242   jresult = (int)result;
69243   return jresult;
69244 }
69245
69246
69247 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
69248   int jresult ;
69249   int result;
69250
69251   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
69252   jresult = (int)result;
69253   return jresult;
69254 }
69255
69256
69257 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
69258   int jresult ;
69259   int result;
69260
69261   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
69262   jresult = (int)result;
69263   return jresult;
69264 }
69265
69266
69267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
69268   int jresult ;
69269   int result;
69270
69271   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
69272   jresult = (int)result;
69273   return jresult;
69274 }
69275
69276
69277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
69278   int jresult ;
69279   int result;
69280
69281   result = (int)Dali::Toolkit::Button::Property::SELECTED;
69282   jresult = (int)result;
69283   return jresult;
69284 }
69285
69286
69287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
69288   int jresult ;
69289   int result;
69290
69291   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
69292   jresult = (int)result;
69293   return jresult;
69294 }
69295
69296
69297 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
69298   int jresult ;
69299   int result;
69300
69301   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
69302   jresult = (int)result;
69303   return jresult;
69304 }
69305
69306
69307 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
69308   int jresult ;
69309   int result;
69310
69311   result = (int)Dali::Toolkit::Button::Property::LABEL;
69312   jresult = (int)result;
69313   return jresult;
69314 }
69315
69316
69317 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
69318   int jresult ;
69319   int result;
69320
69321   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
69322   jresult = (int)result;
69323   return jresult;
69324 }
69325
69326
69327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
69328   void * jresult ;
69329   Dali::Toolkit::Button::Property *result = 0 ;
69330
69331   {
69332     try {
69333       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
69334     } catch (std::out_of_range& e) {
69335       {
69336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69337       };
69338     } catch (std::exception& e) {
69339       {
69340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69341       };
69342     } catch (Dali::DaliException e) {
69343       {
69344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69345       };
69346     } catch (...) {
69347       {
69348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69349       };
69350     }
69351   }
69352
69353   jresult = (void *)result;
69354   return jresult;
69355 }
69356
69357
69358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
69359   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
69360
69361   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
69362   {
69363     try {
69364       delete arg1;
69365     } catch (std::out_of_range& e) {
69366       {
69367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69368       };
69369     } catch (std::exception& e) {
69370       {
69371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69372       };
69373     } catch (Dali::DaliException e) {
69374       {
69375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69376       };
69377     } catch (...) {
69378       {
69379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69380       };
69381     }
69382   }
69383
69384 }
69385
69386
69387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
69388   void * jresult ;
69389   Dali::Toolkit::Button *result = 0 ;
69390
69391   {
69392     try {
69393       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
69394     } catch (std::out_of_range& e) {
69395       {
69396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69397       };
69398     } catch (std::exception& e) {
69399       {
69400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69401       };
69402     } catch (Dali::DaliException e) {
69403       {
69404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69405       };
69406     } catch (...) {
69407       {
69408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69409       };
69410     }
69411   }
69412
69413   jresult = (void *)result;
69414   return jresult;
69415 }
69416
69417
69418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
69419   void * jresult ;
69420   Dali::Toolkit::Button *arg1 = 0 ;
69421   Dali::Toolkit::Button *result = 0 ;
69422
69423   arg1 = (Dali::Toolkit::Button *)jarg1;
69424   if (!arg1) {
69425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69426     return 0;
69427   }
69428   {
69429     try {
69430       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
69431     } catch (std::out_of_range& e) {
69432       {
69433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69434       };
69435     } catch (std::exception& e) {
69436       {
69437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69438       };
69439     } catch (Dali::DaliException e) {
69440       {
69441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69442       };
69443     } catch (...) {
69444       {
69445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69446       };
69447     }
69448   }
69449
69450   jresult = (void *)result;
69451   return jresult;
69452 }
69453
69454
69455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
69456   void * jresult ;
69457   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69458   Dali::Toolkit::Button *arg2 = 0 ;
69459   Dali::Toolkit::Button *result = 0 ;
69460
69461   arg1 = (Dali::Toolkit::Button *)jarg1;
69462   arg2 = (Dali::Toolkit::Button *)jarg2;
69463   if (!arg2) {
69464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69465     return 0;
69466   }
69467   {
69468     try {
69469       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
69470     } catch (std::out_of_range& e) {
69471       {
69472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69473       };
69474     } catch (std::exception& e) {
69475       {
69476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69477       };
69478     } catch (Dali::DaliException e) {
69479       {
69480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69481       };
69482     } catch (...) {
69483       {
69484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69485       };
69486     }
69487   }
69488
69489   jresult = (void *)result;
69490   return jresult;
69491 }
69492
69493
69494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
69495   void * jresult ;
69496   Dali::BaseHandle arg1 ;
69497   Dali::BaseHandle *argp1 ;
69498   Dali::Toolkit::Button result;
69499
69500   argp1 = (Dali::BaseHandle *)jarg1;
69501   if (!argp1) {
69502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69503     return 0;
69504   }
69505   arg1 = *argp1;
69506   {
69507     try {
69508       result = Dali::Toolkit::Button::DownCast(arg1);
69509     } catch (std::out_of_range& e) {
69510       {
69511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69512       };
69513     } catch (std::exception& e) {
69514       {
69515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69516       };
69517     } catch (Dali::DaliException e) {
69518       {
69519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69520       };
69521     } catch (...) {
69522       {
69523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69524       };
69525     }
69526   }
69527
69528   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
69529   return jresult;
69530 }
69531
69532
69533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
69534   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69535
69536   arg1 = (Dali::Toolkit::Button *)jarg1;
69537   {
69538     try {
69539       delete arg1;
69540     } catch (std::out_of_range& e) {
69541       {
69542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69543       };
69544     } catch (std::exception& e) {
69545       {
69546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69547       };
69548     } catch (Dali::DaliException e) {
69549       {
69550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69551       };
69552     } catch (...) {
69553       {
69554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69555       };
69556     }
69557   }
69558
69559 }
69560
69561
69562 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
69563   unsigned int jresult ;
69564   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69565   bool result;
69566
69567   arg1 = (Dali::Toolkit::Button *)jarg1;
69568   {
69569     try {
69570       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
69571     } catch (std::out_of_range& e) {
69572       {
69573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69574       };
69575     } catch (std::exception& e) {
69576       {
69577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69578       };
69579     } catch (Dali::DaliException e) {
69580       {
69581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69582       };
69583     } catch (...) {
69584       {
69585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69586       };
69587     }
69588   }
69589
69590   jresult = result;
69591   return jresult;
69592 }
69593
69594
69595 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
69596   unsigned int jresult ;
69597   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69598   bool result;
69599
69600   arg1 = (Dali::Toolkit::Button *)jarg1;
69601   {
69602     try {
69603       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
69604     } catch (std::out_of_range& e) {
69605       {
69606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69607       };
69608     } catch (std::exception& e) {
69609       {
69610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69611       };
69612     } catch (Dali::DaliException e) {
69613       {
69614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69615       };
69616     } catch (...) {
69617       {
69618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69619       };
69620     }
69621   }
69622
69623   jresult = result;
69624   return jresult;
69625 }
69626
69627
69628 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
69629   float jresult ;
69630   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69631   float result;
69632
69633   arg1 = (Dali::Toolkit::Button *)jarg1;
69634   {
69635     try {
69636       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
69637     } catch (std::out_of_range& e) {
69638       {
69639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69640       };
69641     } catch (std::exception& e) {
69642       {
69643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69644       };
69645     } catch (Dali::DaliException e) {
69646       {
69647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69648       };
69649     } catch (...) {
69650       {
69651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69652       };
69653     }
69654   }
69655
69656   jresult = result;
69657   return jresult;
69658 }
69659
69660
69661 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
69662   float jresult ;
69663   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69664   float result;
69665
69666   arg1 = (Dali::Toolkit::Button *)jarg1;
69667   {
69668     try {
69669       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
69670     } catch (std::out_of_range& e) {
69671       {
69672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69673       };
69674     } catch (std::exception& e) {
69675       {
69676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69677       };
69678     } catch (Dali::DaliException e) {
69679       {
69680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69681       };
69682     } catch (...) {
69683       {
69684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69685       };
69686     }
69687   }
69688
69689   jresult = result;
69690   return jresult;
69691 }
69692
69693
69694 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
69695   unsigned int jresult ;
69696   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69697   bool result;
69698
69699   arg1 = (Dali::Toolkit::Button *)jarg1;
69700   {
69701     try {
69702       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
69703     } catch (std::out_of_range& e) {
69704       {
69705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69706       };
69707     } catch (std::exception& e) {
69708       {
69709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69710       };
69711     } catch (Dali::DaliException e) {
69712       {
69713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69714       };
69715     } catch (...) {
69716       {
69717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69718       };
69719     }
69720   }
69721
69722   jresult = result;
69723   return jresult;
69724 }
69725
69726
69727 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
69728   unsigned int jresult ;
69729   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69730   bool result;
69731
69732   arg1 = (Dali::Toolkit::Button *)jarg1;
69733   {
69734     try {
69735       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
69736     } catch (std::out_of_range& e) {
69737       {
69738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69739       };
69740     } catch (std::exception& e) {
69741       {
69742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69743       };
69744     } catch (Dali::DaliException e) {
69745       {
69746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69747       };
69748     } catch (...) {
69749       {
69750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69751       };
69752     }
69753   }
69754
69755   jresult = result;
69756   return jresult;
69757 }
69758
69759
69760 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
69761   float jresult ;
69762   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69763   float result;
69764
69765   arg1 = (Dali::Toolkit::Button *)jarg1;
69766   {
69767     try {
69768       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
69769     } catch (std::out_of_range& e) {
69770       {
69771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69772       };
69773     } catch (std::exception& e) {
69774       {
69775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69776       };
69777     } catch (Dali::DaliException e) {
69778       {
69779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69780       };
69781     } catch (...) {
69782       {
69783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69784       };
69785     }
69786   }
69787
69788   jresult = result;
69789   return jresult;
69790 }
69791
69792
69793 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
69794   char * jresult ;
69795   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69796   std::string result;
69797
69798   arg1 = (Dali::Toolkit::Button *)jarg1;
69799   {
69800     try {
69801       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
69802     } catch (std::out_of_range& e) {
69803       {
69804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69805       };
69806     } catch (std::exception& e) {
69807       {
69808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69809       };
69810     } catch (Dali::DaliException e) {
69811       {
69812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69813       };
69814     } catch (...) {
69815       {
69816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69817       };
69818     }
69819   }
69820
69821   jresult = SWIG_csharp_string_callback((&result)->c_str());
69822   return jresult;
69823 }
69824
69825
69826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
69827   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69828   Dali::Actor arg2 ;
69829   Dali::Actor *argp2 ;
69830
69831   arg1 = (Dali::Toolkit::Button *)jarg1;
69832   argp2 = (Dali::Actor *)jarg2;
69833   if (!argp2) {
69834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
69835     return ;
69836   }
69837   arg2 = *argp2;
69838   {
69839     try {
69840       (arg1)->SetLabel(arg2);
69841     } catch (std::out_of_range& e) {
69842       {
69843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69844       };
69845     } catch (std::exception& e) {
69846       {
69847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69848       };
69849     } catch (Dali::DaliException e) {
69850       {
69851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69852       };
69853     } catch (...) {
69854       {
69855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69856       };
69857     }
69858   }
69859
69860 }
69861
69862
69863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
69864   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69865   Dali::Image arg2 ;
69866   Dali::Image *argp2 ;
69867
69868   arg1 = (Dali::Toolkit::Button *)jarg1;
69869   argp2 = (Dali::Image *)jarg2;
69870   if (!argp2) {
69871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
69872     return ;
69873   }
69874   arg2 = *argp2;
69875   {
69876     try {
69877       (arg1)->SetButtonImage(arg2);
69878     } catch (std::out_of_range& e) {
69879       {
69880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69881       };
69882     } catch (std::exception& e) {
69883       {
69884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69885       };
69886     } catch (Dali::DaliException e) {
69887       {
69888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69889       };
69890     } catch (...) {
69891       {
69892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69893       };
69894     }
69895   }
69896
69897 }
69898
69899
69900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
69901   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69902   Dali::Image arg2 ;
69903   Dali::Image *argp2 ;
69904
69905   arg1 = (Dali::Toolkit::Button *)jarg1;
69906   argp2 = (Dali::Image *)jarg2;
69907   if (!argp2) {
69908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
69909     return ;
69910   }
69911   arg2 = *argp2;
69912   {
69913     try {
69914       (arg1)->SetSelectedImage(arg2);
69915     } catch (std::out_of_range& e) {
69916       {
69917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69918       };
69919     } catch (std::exception& e) {
69920       {
69921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69922       };
69923     } catch (Dali::DaliException e) {
69924       {
69925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69926       };
69927     } catch (...) {
69928       {
69929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69930       };
69931     }
69932   }
69933
69934 }
69935
69936
69937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
69938   void * jresult ;
69939   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69940   Dali::Actor result;
69941
69942   arg1 = (Dali::Toolkit::Button *)jarg1;
69943   {
69944     try {
69945       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
69946     } catch (std::out_of_range& e) {
69947       {
69948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69949       };
69950     } catch (std::exception& e) {
69951       {
69952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69953       };
69954     } catch (Dali::DaliException e) {
69955       {
69956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69957       };
69958     } catch (...) {
69959       {
69960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69961       };
69962     }
69963   }
69964
69965   jresult = new Dali::Actor((const Dali::Actor &)result);
69966   return jresult;
69967 }
69968
69969
69970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
69971   void * jresult ;
69972   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69973   Dali::Actor result;
69974
69975   arg1 = (Dali::Toolkit::Button *)jarg1;
69976   {
69977     try {
69978       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
69979     } catch (std::out_of_range& e) {
69980       {
69981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69982       };
69983     } catch (std::exception& e) {
69984       {
69985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69986       };
69987     } catch (Dali::DaliException e) {
69988       {
69989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69990       };
69991     } catch (...) {
69992       {
69993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69994       };
69995     }
69996   }
69997
69998   jresult = new Dali::Actor((const Dali::Actor &)result);
69999   return jresult;
70000 }
70001
70002
70003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
70004   void * jresult ;
70005   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70006   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70007
70008   arg1 = (Dali::Toolkit::Button *)jarg1;
70009   {
70010     try {
70011       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
70012     } catch (std::out_of_range& e) {
70013       {
70014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70015       };
70016     } catch (std::exception& e) {
70017       {
70018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70019       };
70020     } catch (Dali::DaliException e) {
70021       {
70022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70023       };
70024     } catch (...) {
70025       {
70026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70027       };
70028     }
70029   }
70030
70031   jresult = (void *)result;
70032   return jresult;
70033 }
70034
70035
70036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
70037   void * jresult ;
70038   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70039   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70040
70041   arg1 = (Dali::Toolkit::Button *)jarg1;
70042   {
70043     try {
70044       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
70045     } catch (std::out_of_range& e) {
70046       {
70047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70048       };
70049     } catch (std::exception& e) {
70050       {
70051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70052       };
70053     } catch (Dali::DaliException e) {
70054       {
70055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70056       };
70057     } catch (...) {
70058       {
70059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70060       };
70061     }
70062   }
70063
70064   jresult = (void *)result;
70065   return jresult;
70066 }
70067
70068
70069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
70070   void * jresult ;
70071   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70072   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70073
70074   arg1 = (Dali::Toolkit::Button *)jarg1;
70075   {
70076     try {
70077       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
70078     } catch (std::out_of_range& e) {
70079       {
70080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70081       };
70082     } catch (std::exception& e) {
70083       {
70084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70085       };
70086     } catch (Dali::DaliException e) {
70087       {
70088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70089       };
70090     } catch (...) {
70091       {
70092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70093       };
70094     }
70095   }
70096
70097   jresult = (void *)result;
70098   return jresult;
70099 }
70100
70101
70102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
70103   void * jresult ;
70104   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70105   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70106
70107   arg1 = (Dali::Toolkit::Button *)jarg1;
70108   {
70109     try {
70110       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
70111     } catch (std::out_of_range& e) {
70112       {
70113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70114       };
70115     } catch (std::exception& e) {
70116       {
70117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70118       };
70119     } catch (Dali::DaliException e) {
70120       {
70121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70122       };
70123     } catch (...) {
70124       {
70125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70126       };
70127     }
70128   }
70129
70130   jresult = (void *)result;
70131   return jresult;
70132 }
70133
70134
70135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
70136   void * jresult ;
70137   Dali::Toolkit::CheckBoxButton *result = 0 ;
70138
70139   {
70140     try {
70141       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
70142     } catch (std::out_of_range& e) {
70143       {
70144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70145       };
70146     } catch (std::exception& e) {
70147       {
70148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70149       };
70150     } catch (Dali::DaliException e) {
70151       {
70152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70153       };
70154     } catch (...) {
70155       {
70156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70157       };
70158     }
70159   }
70160
70161   jresult = (void *)result;
70162   return jresult;
70163 }
70164
70165
70166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
70167   void * jresult ;
70168   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
70169   Dali::Toolkit::CheckBoxButton *result = 0 ;
70170
70171   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70172   if (!arg1) {
70173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70174     return 0;
70175   }
70176   {
70177     try {
70178       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
70179     } catch (std::out_of_range& e) {
70180       {
70181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70182       };
70183     } catch (std::exception& e) {
70184       {
70185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70186       };
70187     } catch (Dali::DaliException e) {
70188       {
70189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70190       };
70191     } catch (...) {
70192       {
70193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70194       };
70195     }
70196   }
70197
70198   jresult = (void *)result;
70199   return jresult;
70200 }
70201
70202
70203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
70204   void * jresult ;
70205   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70206   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
70207   Dali::Toolkit::CheckBoxButton *result = 0 ;
70208
70209   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70210   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
70211   if (!arg2) {
70212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70213     return 0;
70214   }
70215   {
70216     try {
70217       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
70218     } catch (std::out_of_range& e) {
70219       {
70220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70221       };
70222     } catch (std::exception& e) {
70223       {
70224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70225       };
70226     } catch (Dali::DaliException e) {
70227       {
70228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70229       };
70230     } catch (...) {
70231       {
70232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70233       };
70234     }
70235   }
70236
70237   jresult = (void *)result;
70238   return jresult;
70239 }
70240
70241
70242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
70243   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70244
70245   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70246   {
70247     try {
70248       delete arg1;
70249     } catch (std::out_of_range& e) {
70250       {
70251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70252       };
70253     } catch (std::exception& e) {
70254       {
70255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70256       };
70257     } catch (Dali::DaliException e) {
70258       {
70259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70260       };
70261     } catch (...) {
70262       {
70263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70264       };
70265     }
70266   }
70267
70268 }
70269
70270
70271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
70272   void * jresult ;
70273   Dali::Toolkit::CheckBoxButton result;
70274
70275   {
70276     try {
70277       result = Dali::Toolkit::CheckBoxButton::New();
70278     } catch (std::out_of_range& e) {
70279       {
70280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70281       };
70282     } catch (std::exception& e) {
70283       {
70284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70285       };
70286     } catch (Dali::DaliException e) {
70287       {
70288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70289       };
70290     } catch (...) {
70291       {
70292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70293       };
70294     }
70295   }
70296
70297   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70298   return jresult;
70299 }
70300
70301
70302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
70303   void * jresult ;
70304   Dali::BaseHandle arg1 ;
70305   Dali::BaseHandle *argp1 ;
70306   Dali::Toolkit::CheckBoxButton result;
70307
70308   argp1 = (Dali::BaseHandle *)jarg1;
70309   if (!argp1) {
70310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70311     return 0;
70312   }
70313   arg1 = *argp1;
70314   {
70315     try {
70316       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
70317     } catch (std::out_of_range& e) {
70318       {
70319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70320       };
70321     } catch (std::exception& e) {
70322       {
70323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70324       };
70325     } catch (Dali::DaliException e) {
70326       {
70327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70328       };
70329     } catch (...) {
70330       {
70331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70332       };
70333     }
70334   }
70335
70336   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70337   return jresult;
70338 }
70339
70340
70341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
70342   int jresult ;
70343   int result;
70344
70345   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
70346   jresult = (int)result;
70347   return jresult;
70348 }
70349
70350
70351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
70352   int jresult ;
70353   int result;
70354
70355   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
70356   jresult = (int)result;
70357   return jresult;
70358 }
70359
70360
70361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
70362   int jresult ;
70363   int result;
70364
70365   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
70366   jresult = (int)result;
70367   return jresult;
70368 }
70369
70370
70371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
70372   int jresult ;
70373   int result;
70374
70375   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
70376   jresult = (int)result;
70377   return jresult;
70378 }
70379
70380
70381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
70382   int jresult ;
70383   int result;
70384
70385   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
70386   jresult = (int)result;
70387   return jresult;
70388 }
70389
70390
70391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
70392   void * jresult ;
70393   Dali::Toolkit::PushButton::Property *result = 0 ;
70394
70395   {
70396     try {
70397       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
70398     } catch (std::out_of_range& e) {
70399       {
70400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70401       };
70402     } catch (std::exception& e) {
70403       {
70404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70405       };
70406     } catch (Dali::DaliException e) {
70407       {
70408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70409       };
70410     } catch (...) {
70411       {
70412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70413       };
70414     }
70415   }
70416
70417   jresult = (void *)result;
70418   return jresult;
70419 }
70420
70421
70422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
70423   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
70424
70425   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
70426   {
70427     try {
70428       delete arg1;
70429     } catch (std::out_of_range& e) {
70430       {
70431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70432       };
70433     } catch (std::exception& e) {
70434       {
70435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70436       };
70437     } catch (Dali::DaliException e) {
70438       {
70439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70440       };
70441     } catch (...) {
70442       {
70443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70444       };
70445     }
70446   }
70447
70448 }
70449
70450
70451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
70452   void * jresult ;
70453   Dali::Toolkit::PushButton *result = 0 ;
70454
70455   {
70456     try {
70457       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
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 = (void *)result;
70478   return jresult;
70479 }
70480
70481
70482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
70483   void * jresult ;
70484   Dali::Toolkit::PushButton *arg1 = 0 ;
70485   Dali::Toolkit::PushButton *result = 0 ;
70486
70487   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70488   if (!arg1) {
70489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70490     return 0;
70491   }
70492   {
70493     try {
70494       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
70495     } catch (std::out_of_range& e) {
70496       {
70497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70498       };
70499     } catch (std::exception& e) {
70500       {
70501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70502       };
70503     } catch (Dali::DaliException e) {
70504       {
70505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70506       };
70507     } catch (...) {
70508       {
70509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70510       };
70511     }
70512   }
70513
70514   jresult = (void *)result;
70515   return jresult;
70516 }
70517
70518
70519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
70520   void * jresult ;
70521   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70522   Dali::Toolkit::PushButton *arg2 = 0 ;
70523   Dali::Toolkit::PushButton *result = 0 ;
70524
70525   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70526   arg2 = (Dali::Toolkit::PushButton *)jarg2;
70527   if (!arg2) {
70528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70529     return 0;
70530   }
70531   {
70532     try {
70533       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
70534     } catch (std::out_of_range& e) {
70535       {
70536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70537       };
70538     } catch (std::exception& e) {
70539       {
70540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70541       };
70542     } catch (Dali::DaliException e) {
70543       {
70544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70545       };
70546     } catch (...) {
70547       {
70548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70549       };
70550     }
70551   }
70552
70553   jresult = (void *)result;
70554   return jresult;
70555 }
70556
70557
70558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
70559   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70560
70561   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70562   {
70563     try {
70564       delete arg1;
70565     } catch (std::out_of_range& e) {
70566       {
70567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70568       };
70569     } catch (std::exception& e) {
70570       {
70571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70572       };
70573     } catch (Dali::DaliException e) {
70574       {
70575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70576       };
70577     } catch (...) {
70578       {
70579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70580       };
70581     }
70582   }
70583
70584 }
70585
70586
70587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
70588   void * jresult ;
70589   Dali::Toolkit::PushButton result;
70590
70591   {
70592     try {
70593       result = Dali::Toolkit::PushButton::New();
70594     } catch (std::out_of_range& e) {
70595       {
70596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70597       };
70598     } catch (std::exception& e) {
70599       {
70600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70601       };
70602     } catch (Dali::DaliException e) {
70603       {
70604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70605       };
70606     } catch (...) {
70607       {
70608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70609       };
70610     }
70611   }
70612
70613   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
70614   return jresult;
70615 }
70616
70617
70618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
70619   void * jresult ;
70620   Dali::BaseHandle arg1 ;
70621   Dali::BaseHandle *argp1 ;
70622   Dali::Toolkit::PushButton result;
70623
70624   argp1 = (Dali::BaseHandle *)jarg1;
70625   if (!argp1) {
70626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70627     return 0;
70628   }
70629   arg1 = *argp1;
70630   {
70631     try {
70632       result = Dali::Toolkit::PushButton::DownCast(arg1);
70633     } catch (std::out_of_range& e) {
70634       {
70635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70636       };
70637     } catch (std::exception& e) {
70638       {
70639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70640       };
70641     } catch (Dali::DaliException e) {
70642       {
70643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70644       };
70645     } catch (...) {
70646       {
70647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70648       };
70649     }
70650   }
70651
70652   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
70653   return jresult;
70654 }
70655
70656
70657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
70658   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70659   Dali::Image arg2 ;
70660   Dali::Image *argp2 ;
70661
70662   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70663   argp2 = (Dali::Image *)jarg2;
70664   if (!argp2) {
70665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70666     return ;
70667   }
70668   arg2 = *argp2;
70669   {
70670     try {
70671       (arg1)->SetButtonImage(arg2);
70672     } catch (std::out_of_range& e) {
70673       {
70674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70675       };
70676     } catch (std::exception& e) {
70677       {
70678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70679       };
70680     } catch (Dali::DaliException e) {
70681       {
70682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70683       };
70684     } catch (...) {
70685       {
70686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70687       };
70688     }
70689   }
70690
70691 }
70692
70693
70694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
70695   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70696   Dali::Actor arg2 ;
70697   Dali::Actor *argp2 ;
70698
70699   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70700   argp2 = (Dali::Actor *)jarg2;
70701   if (!argp2) {
70702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70703     return ;
70704   }
70705   arg2 = *argp2;
70706   {
70707     try {
70708       (arg1)->SetButtonImage(arg2);
70709     } catch (std::out_of_range& e) {
70710       {
70711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70712       };
70713     } catch (std::exception& e) {
70714       {
70715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70716       };
70717     } catch (Dali::DaliException e) {
70718       {
70719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70720       };
70721     } catch (...) {
70722       {
70723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70724       };
70725     }
70726   }
70727
70728 }
70729
70730
70731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
70732   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70733   Dali::Actor arg2 ;
70734   Dali::Actor *argp2 ;
70735
70736   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70737   argp2 = (Dali::Actor *)jarg2;
70738   if (!argp2) {
70739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70740     return ;
70741   }
70742   arg2 = *argp2;
70743   {
70744     try {
70745       (arg1)->SetBackgroundImage(arg2);
70746     } catch (std::out_of_range& e) {
70747       {
70748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70749       };
70750     } catch (std::exception& e) {
70751       {
70752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70753       };
70754     } catch (Dali::DaliException e) {
70755       {
70756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70757       };
70758     } catch (...) {
70759       {
70760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70761       };
70762     }
70763   }
70764
70765 }
70766
70767
70768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
70769   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70770   Dali::Image arg2 ;
70771   Dali::Image *argp2 ;
70772
70773   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70774   argp2 = (Dali::Image *)jarg2;
70775   if (!argp2) {
70776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70777     return ;
70778   }
70779   arg2 = *argp2;
70780   {
70781     try {
70782       (arg1)->SetSelectedImage(arg2);
70783     } catch (std::out_of_range& e) {
70784       {
70785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70786       };
70787     } catch (std::exception& e) {
70788       {
70789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70790       };
70791     } catch (Dali::DaliException e) {
70792       {
70793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70794       };
70795     } catch (...) {
70796       {
70797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70798       };
70799     }
70800   }
70801
70802 }
70803
70804
70805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
70806   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70807   Dali::Actor arg2 ;
70808   Dali::Actor *argp2 ;
70809
70810   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70811   argp2 = (Dali::Actor *)jarg2;
70812   if (!argp2) {
70813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70814     return ;
70815   }
70816   arg2 = *argp2;
70817   {
70818     try {
70819       (arg1)->SetSelectedImage(arg2);
70820     } catch (std::out_of_range& e) {
70821       {
70822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70823       };
70824     } catch (std::exception& e) {
70825       {
70826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70827       };
70828     } catch (Dali::DaliException e) {
70829       {
70830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70831       };
70832     } catch (...) {
70833       {
70834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70835       };
70836     }
70837   }
70838
70839 }
70840
70841
70842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
70843   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70844   Dali::Actor arg2 ;
70845   Dali::Actor *argp2 ;
70846
70847   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70848   argp2 = (Dali::Actor *)jarg2;
70849   if (!argp2) {
70850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70851     return ;
70852   }
70853   arg2 = *argp2;
70854   {
70855     try {
70856       (arg1)->SetSelectedBackgroundImage(arg2);
70857     } catch (std::out_of_range& e) {
70858       {
70859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70860       };
70861     } catch (std::exception& e) {
70862       {
70863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70864       };
70865     } catch (Dali::DaliException e) {
70866       {
70867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70868       };
70869     } catch (...) {
70870       {
70871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70872       };
70873     }
70874   }
70875
70876 }
70877
70878
70879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
70880   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70881   Dali::Actor arg2 ;
70882   Dali::Actor *argp2 ;
70883
70884   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70885   argp2 = (Dali::Actor *)jarg2;
70886   if (!argp2) {
70887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70888     return ;
70889   }
70890   arg2 = *argp2;
70891   {
70892     try {
70893       (arg1)->SetDisabledBackgroundImage(arg2);
70894     } catch (std::out_of_range& e) {
70895       {
70896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70897       };
70898     } catch (std::exception& e) {
70899       {
70900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70901       };
70902     } catch (Dali::DaliException e) {
70903       {
70904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70905       };
70906     } catch (...) {
70907       {
70908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70909       };
70910     }
70911   }
70912
70913 }
70914
70915
70916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
70917   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70918   Dali::Actor arg2 ;
70919   Dali::Actor *argp2 ;
70920
70921   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70922   argp2 = (Dali::Actor *)jarg2;
70923   if (!argp2) {
70924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70925     return ;
70926   }
70927   arg2 = *argp2;
70928   {
70929     try {
70930       (arg1)->SetDisabledImage(arg2);
70931     } catch (std::out_of_range& e) {
70932       {
70933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70934       };
70935     } catch (std::exception& e) {
70936       {
70937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70938       };
70939     } catch (Dali::DaliException e) {
70940       {
70941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70942       };
70943     } catch (...) {
70944       {
70945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70946       };
70947     }
70948   }
70949
70950 }
70951
70952
70953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
70954   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70955   Dali::Actor arg2 ;
70956   Dali::Actor *argp2 ;
70957
70958   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70959   argp2 = (Dali::Actor *)jarg2;
70960   if (!argp2) {
70961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70962     return ;
70963   }
70964   arg2 = *argp2;
70965   {
70966     try {
70967       (arg1)->SetDisabledSelectedImage(arg2);
70968     } catch (std::out_of_range& e) {
70969       {
70970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70971       };
70972     } catch (std::exception& e) {
70973       {
70974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70975       };
70976     } catch (Dali::DaliException e) {
70977       {
70978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70979       };
70980     } catch (...) {
70981       {
70982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70983       };
70984     }
70985   }
70986
70987 }
70988
70989
70990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
70991   void * jresult ;
70992   Dali::Toolkit::RadioButton *result = 0 ;
70993
70994   {
70995     try {
70996       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
70997     } catch (std::out_of_range& e) {
70998       {
70999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71000       };
71001     } catch (std::exception& e) {
71002       {
71003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71004       };
71005     } catch (Dali::DaliException e) {
71006       {
71007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71008       };
71009     } catch (...) {
71010       {
71011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71012       };
71013     }
71014   }
71015
71016   jresult = (void *)result;
71017   return jresult;
71018 }
71019
71020
71021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
71022   void * jresult ;
71023   Dali::Toolkit::RadioButton *arg1 = 0 ;
71024   Dali::Toolkit::RadioButton *result = 0 ;
71025
71026   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71027   if (!arg1) {
71028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
71029     return 0;
71030   }
71031   {
71032     try {
71033       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
71034     } catch (std::out_of_range& e) {
71035       {
71036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71037       };
71038     } catch (std::exception& e) {
71039       {
71040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71041       };
71042     } catch (Dali::DaliException e) {
71043       {
71044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71045       };
71046     } catch (...) {
71047       {
71048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71049       };
71050     }
71051   }
71052
71053   jresult = (void *)result;
71054   return jresult;
71055 }
71056
71057
71058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
71059   void * jresult ;
71060   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
71061   Dali::Toolkit::RadioButton *arg2 = 0 ;
71062   Dali::Toolkit::RadioButton *result = 0 ;
71063
71064   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71065   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
71066   if (!arg2) {
71067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
71068     return 0;
71069   }
71070   {
71071     try {
71072       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
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 = (void *)result;
71093   return jresult;
71094 }
71095
71096
71097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
71098   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
71099
71100   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71101   {
71102     try {
71103       delete arg1;
71104     } catch (std::out_of_range& e) {
71105       {
71106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71107       };
71108     } catch (std::exception& e) {
71109       {
71110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71111       };
71112     } catch (Dali::DaliException e) {
71113       {
71114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71115       };
71116     } catch (...) {
71117       {
71118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71119       };
71120     }
71121   }
71122
71123 }
71124
71125
71126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
71127   void * jresult ;
71128   Dali::Toolkit::RadioButton result;
71129
71130   {
71131     try {
71132       result = Dali::Toolkit::RadioButton::New();
71133     } catch (std::out_of_range& e) {
71134       {
71135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71136       };
71137     } catch (std::exception& e) {
71138       {
71139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71140       };
71141     } catch (Dali::DaliException e) {
71142       {
71143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71144       };
71145     } catch (...) {
71146       {
71147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71148       };
71149     }
71150   }
71151
71152   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71153   return jresult;
71154 }
71155
71156
71157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
71158   void * jresult ;
71159   std::string *arg1 = 0 ;
71160   Dali::Toolkit::RadioButton result;
71161
71162   if (!jarg1) {
71163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71164     return 0;
71165   }
71166   std::string arg1_str(jarg1);
71167   arg1 = &arg1_str;
71168   {
71169     try {
71170       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
71171     } catch (std::out_of_range& e) {
71172       {
71173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71174       };
71175     } catch (std::exception& e) {
71176       {
71177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71178       };
71179     } catch (Dali::DaliException e) {
71180       {
71181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71182       };
71183     } catch (...) {
71184       {
71185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71186       };
71187     }
71188   }
71189
71190   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71191
71192   //argout typemap for const std::string&
71193
71194   return jresult;
71195 }
71196
71197
71198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
71199   void * jresult ;
71200   Dali::BaseHandle arg1 ;
71201   Dali::BaseHandle *argp1 ;
71202   Dali::Toolkit::RadioButton result;
71203
71204   argp1 = (Dali::BaseHandle *)jarg1;
71205   if (!argp1) {
71206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71207     return 0;
71208   }
71209   arg1 = *argp1;
71210   {
71211     try {
71212       result = Dali::Toolkit::RadioButton::DownCast(arg1);
71213     } catch (std::out_of_range& e) {
71214       {
71215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71216       };
71217     } catch (std::exception& e) {
71218       {
71219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71220       };
71221     } catch (Dali::DaliException e) {
71222       {
71223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71224       };
71225     } catch (...) {
71226       {
71227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71228       };
71229     }
71230   }
71231
71232   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71233   return jresult;
71234 }
71235
71236
71237 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
71238   int jresult ;
71239   int result;
71240
71241   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
71242   jresult = (int)result;
71243   return jresult;
71244 }
71245
71246
71247 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
71248   int jresult ;
71249   int result;
71250
71251   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
71252   jresult = (int)result;
71253   return jresult;
71254 }
71255
71256
71257 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
71258   int jresult ;
71259   int result;
71260
71261   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
71262   jresult = (int)result;
71263   return jresult;
71264 }
71265
71266
71267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
71268   int jresult ;
71269   int result;
71270
71271   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
71272   jresult = (int)result;
71273   return jresult;
71274 }
71275
71276
71277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
71278   int jresult ;
71279   int result;
71280
71281   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
71282   jresult = (int)result;
71283   return jresult;
71284 }
71285
71286
71287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
71288   int jresult ;
71289   int result;
71290
71291   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
71292   jresult = (int)result;
71293   return jresult;
71294 }
71295
71296
71297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
71298   void * jresult ;
71299   Dali::Toolkit::FlexContainer::Property *result = 0 ;
71300
71301   {
71302     try {
71303       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
71304     } catch (std::out_of_range& e) {
71305       {
71306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71307       };
71308     } catch (std::exception& e) {
71309       {
71310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71311       };
71312     } catch (Dali::DaliException e) {
71313       {
71314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71315       };
71316     } catch (...) {
71317       {
71318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71319       };
71320     }
71321   }
71322
71323   jresult = (void *)result;
71324   return jresult;
71325 }
71326
71327
71328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
71329   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
71330
71331   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
71332   {
71333     try {
71334       delete arg1;
71335     } catch (std::out_of_range& e) {
71336       {
71337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71338       };
71339     } catch (std::exception& e) {
71340       {
71341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71342       };
71343     } catch (Dali::DaliException e) {
71344       {
71345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71346       };
71347     } catch (...) {
71348       {
71349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71350       };
71351     }
71352   }
71353
71354 }
71355
71356
71357 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
71358   int jresult ;
71359   int result;
71360
71361   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
71362   jresult = (int)result;
71363   return jresult;
71364 }
71365
71366
71367 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
71368   int jresult ;
71369   int result;
71370
71371   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
71372   jresult = (int)result;
71373   return jresult;
71374 }
71375
71376
71377 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
71378   int jresult ;
71379   int result;
71380
71381   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
71382   jresult = (int)result;
71383   return jresult;
71384 }
71385
71386
71387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
71388   void * jresult ;
71389   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
71390
71391   {
71392     try {
71393       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
71394     } catch (std::out_of_range& e) {
71395       {
71396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71397       };
71398     } catch (std::exception& e) {
71399       {
71400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71401       };
71402     } catch (Dali::DaliException e) {
71403       {
71404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71405       };
71406     } catch (...) {
71407       {
71408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71409       };
71410     }
71411   }
71412
71413   jresult = (void *)result;
71414   return jresult;
71415 }
71416
71417
71418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
71419   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
71420
71421   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
71422   {
71423     try {
71424       delete arg1;
71425     } catch (std::out_of_range& e) {
71426       {
71427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71428       };
71429     } catch (std::exception& e) {
71430       {
71431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71432       };
71433     } catch (Dali::DaliException e) {
71434       {
71435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71436       };
71437     } catch (...) {
71438       {
71439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71440       };
71441     }
71442   }
71443
71444 }
71445
71446
71447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
71448   void * jresult ;
71449   Dali::Toolkit::FlexContainer *result = 0 ;
71450
71451   {
71452     try {
71453       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
71454     } catch (std::out_of_range& e) {
71455       {
71456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71457       };
71458     } catch (std::exception& e) {
71459       {
71460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71461       };
71462     } catch (Dali::DaliException e) {
71463       {
71464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71465       };
71466     } catch (...) {
71467       {
71468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71469       };
71470     }
71471   }
71472
71473   jresult = (void *)result;
71474   return jresult;
71475 }
71476
71477
71478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
71479   void * jresult ;
71480   Dali::Toolkit::FlexContainer *arg1 = 0 ;
71481   Dali::Toolkit::FlexContainer *result = 0 ;
71482
71483   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71484   if (!arg1) {
71485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71486     return 0;
71487   }
71488   {
71489     try {
71490       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
71491     } catch (std::out_of_range& e) {
71492       {
71493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71494       };
71495     } catch (std::exception& e) {
71496       {
71497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71498       };
71499     } catch (Dali::DaliException e) {
71500       {
71501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71502       };
71503     } catch (...) {
71504       {
71505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71506       };
71507     }
71508   }
71509
71510   jresult = (void *)result;
71511   return jresult;
71512 }
71513
71514
71515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
71516   void * jresult ;
71517   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71518   Dali::Toolkit::FlexContainer *arg2 = 0 ;
71519   Dali::Toolkit::FlexContainer *result = 0 ;
71520
71521   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71522   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
71523   if (!arg2) {
71524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71525     return 0;
71526   }
71527   {
71528     try {
71529       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
71530     } catch (std::out_of_range& e) {
71531       {
71532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71533       };
71534     } catch (std::exception& e) {
71535       {
71536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71537       };
71538     } catch (Dali::DaliException e) {
71539       {
71540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71541       };
71542     } catch (...) {
71543       {
71544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71545       };
71546     }
71547   }
71548
71549   jresult = (void *)result;
71550   return jresult;
71551 }
71552
71553
71554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
71555   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71556
71557   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71558   {
71559     try {
71560       delete arg1;
71561     } catch (std::out_of_range& e) {
71562       {
71563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71564       };
71565     } catch (std::exception& e) {
71566       {
71567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71568       };
71569     } catch (Dali::DaliException e) {
71570       {
71571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71572       };
71573     } catch (...) {
71574       {
71575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71576       };
71577     }
71578   }
71579
71580 }
71581
71582
71583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
71584   void * jresult ;
71585   Dali::Toolkit::FlexContainer result;
71586
71587   {
71588     try {
71589       result = Dali::Toolkit::FlexContainer::New();
71590     } catch (std::out_of_range& e) {
71591       {
71592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71593       };
71594     } catch (std::exception& e) {
71595       {
71596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71597       };
71598     } catch (Dali::DaliException e) {
71599       {
71600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71601       };
71602     } catch (...) {
71603       {
71604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71605       };
71606     }
71607   }
71608
71609   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
71610   return jresult;
71611 }
71612
71613
71614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
71615   void * jresult ;
71616   Dali::BaseHandle arg1 ;
71617   Dali::BaseHandle *argp1 ;
71618   Dali::Toolkit::FlexContainer result;
71619
71620   argp1 = (Dali::BaseHandle *)jarg1;
71621   if (!argp1) {
71622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71623     return 0;
71624   }
71625   arg1 = *argp1;
71626   {
71627     try {
71628       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
71629     } catch (std::out_of_range& e) {
71630       {
71631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71632       };
71633     } catch (std::exception& e) {
71634       {
71635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71636       };
71637     } catch (Dali::DaliException e) {
71638       {
71639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71640       };
71641     } catch (...) {
71642       {
71643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71644       };
71645     }
71646   }
71647
71648   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
71649   return jresult;
71650 }
71651
71652
71653 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
71654   int jresult ;
71655   int result;
71656
71657   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
71658   jresult = (int)result;
71659   return jresult;
71660 }
71661
71662
71663 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
71664   int jresult ;
71665   int result;
71666
71667   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
71668   jresult = (int)result;
71669   return jresult;
71670 }
71671
71672
71673 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
71674   int jresult ;
71675   int result;
71676
71677   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
71678   jresult = (int)result;
71679   return jresult;
71680 }
71681
71682
71683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
71684   int jresult ;
71685   int result;
71686
71687   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
71688   jresult = (int)result;
71689   return jresult;
71690 }
71691
71692
71693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
71694   void * jresult ;
71695   Dali::Toolkit::ImageView::Property *result = 0 ;
71696
71697   {
71698     try {
71699       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
71700     } catch (std::out_of_range& e) {
71701       {
71702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71703       };
71704     } catch (std::exception& e) {
71705       {
71706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71707       };
71708     } catch (Dali::DaliException e) {
71709       {
71710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71711       };
71712     } catch (...) {
71713       {
71714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71715       };
71716     }
71717   }
71718
71719   jresult = (void *)result;
71720   return jresult;
71721 }
71722
71723
71724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
71725   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
71726
71727   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
71728   {
71729     try {
71730       delete arg1;
71731     } catch (std::out_of_range& e) {
71732       {
71733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71734       };
71735     } catch (std::exception& e) {
71736       {
71737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71738       };
71739     } catch (Dali::DaliException e) {
71740       {
71741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71742       };
71743     } catch (...) {
71744       {
71745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71746       };
71747     }
71748   }
71749
71750 }
71751
71752
71753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
71754   void * jresult ;
71755   Dali::Toolkit::ImageView *result = 0 ;
71756
71757   {
71758     try {
71759       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
71760     } catch (std::out_of_range& e) {
71761       {
71762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71763       };
71764     } catch (std::exception& e) {
71765       {
71766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71767       };
71768     } catch (Dali::DaliException e) {
71769       {
71770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71771       };
71772     } catch (...) {
71773       {
71774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71775       };
71776     }
71777   }
71778
71779   jresult = (void *)result;
71780   return jresult;
71781 }
71782
71783
71784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
71785   void * jresult ;
71786   Dali::Toolkit::ImageView result;
71787
71788   {
71789     try {
71790       result = Dali::Toolkit::ImageView::New();
71791     } catch (std::out_of_range& e) {
71792       {
71793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71794       };
71795     } catch (std::exception& e) {
71796       {
71797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71798       };
71799     } catch (Dali::DaliException e) {
71800       {
71801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71802       };
71803     } catch (...) {
71804       {
71805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71806       };
71807     }
71808   }
71809
71810   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71811   return jresult;
71812 }
71813
71814
71815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
71816   void * jresult ;
71817   Dali::Image arg1 ;
71818   Dali::Image *argp1 ;
71819   Dali::Toolkit::ImageView result;
71820
71821   argp1 = (Dali::Image *)jarg1;
71822   if (!argp1) {
71823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71824     return 0;
71825   }
71826   arg1 = *argp1;
71827   {
71828     try {
71829       result = Dali::Toolkit::ImageView::New(arg1);
71830     } catch (std::out_of_range& e) {
71831       {
71832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71833       };
71834     } catch (std::exception& e) {
71835       {
71836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71837       };
71838     } catch (Dali::DaliException e) {
71839       {
71840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71841       };
71842     } catch (...) {
71843       {
71844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71845       };
71846     }
71847   }
71848
71849   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71850   return jresult;
71851 }
71852
71853
71854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
71855   void * jresult ;
71856   std::string *arg1 = 0 ;
71857   Dali::Toolkit::ImageView result;
71858
71859   if (!jarg1) {
71860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71861     return 0;
71862   }
71863   std::string arg1_str(jarg1);
71864   arg1 = &arg1_str;
71865   {
71866     try {
71867       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
71868     } catch (std::out_of_range& e) {
71869       {
71870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71871       };
71872     } catch (std::exception& e) {
71873       {
71874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71875       };
71876     } catch (Dali::DaliException e) {
71877       {
71878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71879       };
71880     } catch (...) {
71881       {
71882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71883       };
71884     }
71885   }
71886
71887   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71888
71889   //argout typemap for const std::string&
71890
71891   return jresult;
71892 }
71893
71894
71895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
71896   void * jresult ;
71897   std::string *arg1 = 0 ;
71898   Dali::ImageDimensions arg2 ;
71899   Dali::ImageDimensions *argp2 ;
71900   Dali::Toolkit::ImageView result;
71901
71902   if (!jarg1) {
71903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71904     return 0;
71905   }
71906   std::string arg1_str(jarg1);
71907   arg1 = &arg1_str;
71908   argp2 = (Dali::ImageDimensions *)jarg2;
71909   if (!argp2) {
71910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
71911     return 0;
71912   }
71913   arg2 = *argp2;
71914   {
71915     try {
71916       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
71917     } catch (std::out_of_range& e) {
71918       {
71919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71920       };
71921     } catch (std::exception& e) {
71922       {
71923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71924       };
71925     } catch (Dali::DaliException e) {
71926       {
71927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71928       };
71929     } catch (...) {
71930       {
71931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71932       };
71933     }
71934   }
71935
71936   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71937
71938   //argout typemap for const std::string&
71939
71940   return jresult;
71941 }
71942
71943
71944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
71945   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71946
71947   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71948   {
71949     try {
71950       delete arg1;
71951     } catch (std::out_of_range& e) {
71952       {
71953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71954       };
71955     } catch (std::exception& e) {
71956       {
71957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71958       };
71959     } catch (Dali::DaliException e) {
71960       {
71961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71962       };
71963     } catch (...) {
71964       {
71965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71966       };
71967     }
71968   }
71969
71970 }
71971
71972
71973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
71974   void * jresult ;
71975   Dali::Toolkit::ImageView *arg1 = 0 ;
71976   Dali::Toolkit::ImageView *result = 0 ;
71977
71978   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71979   if (!arg1) {
71980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
71981     return 0;
71982   }
71983   {
71984     try {
71985       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
71986     } catch (std::out_of_range& e) {
71987       {
71988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71989       };
71990     } catch (std::exception& e) {
71991       {
71992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71993       };
71994     } catch (Dali::DaliException e) {
71995       {
71996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71997       };
71998     } catch (...) {
71999       {
72000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72001       };
72002     }
72003   }
72004
72005   jresult = (void *)result;
72006   return jresult;
72007 }
72008
72009
72010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
72011   void * jresult ;
72012   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72013   Dali::Toolkit::ImageView *arg2 = 0 ;
72014   Dali::Toolkit::ImageView *result = 0 ;
72015
72016   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72017   arg2 = (Dali::Toolkit::ImageView *)jarg2;
72018   if (!arg2) {
72019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
72020     return 0;
72021   }
72022   {
72023     try {
72024       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
72025     } catch (std::out_of_range& e) {
72026       {
72027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72028       };
72029     } catch (std::exception& e) {
72030       {
72031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72032       };
72033     } catch (Dali::DaliException e) {
72034       {
72035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72036       };
72037     } catch (...) {
72038       {
72039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72040       };
72041     }
72042   }
72043
72044   jresult = (void *)result;
72045   return jresult;
72046 }
72047
72048
72049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
72050   void * jresult ;
72051   Dali::BaseHandle arg1 ;
72052   Dali::BaseHandle *argp1 ;
72053   Dali::Toolkit::ImageView result;
72054
72055   argp1 = (Dali::BaseHandle *)jarg1;
72056   if (!argp1) {
72057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72058     return 0;
72059   }
72060   arg1 = *argp1;
72061   {
72062     try {
72063       result = Dali::Toolkit::ImageView::DownCast(arg1);
72064     } catch (std::out_of_range& e) {
72065       {
72066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72067       };
72068     } catch (std::exception& e) {
72069       {
72070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72071       };
72072     } catch (Dali::DaliException e) {
72073       {
72074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72075       };
72076     } catch (...) {
72077       {
72078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72079       };
72080     }
72081   }
72082
72083   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72084   return jresult;
72085 }
72086
72087
72088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
72089   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72090   Dali::Image arg2 ;
72091   Dali::Image *argp2 ;
72092
72093   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72094   argp2 = (Dali::Image *)jarg2;
72095   if (!argp2) {
72096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
72097     return ;
72098   }
72099   arg2 = *argp2;
72100   {
72101     try {
72102       (arg1)->SetImage(arg2);
72103     } catch (std::out_of_range& e) {
72104       {
72105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72106       };
72107     } catch (std::exception& e) {
72108       {
72109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72110       };
72111     } catch (Dali::DaliException e) {
72112       {
72113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72114       };
72115     } catch (...) {
72116       {
72117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72118       };
72119     }
72120   }
72121
72122 }
72123
72124
72125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
72126   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72127   std::string *arg2 = 0 ;
72128
72129   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72130   if (!jarg2) {
72131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72132     return ;
72133   }
72134   std::string arg2_str(jarg2);
72135   arg2 = &arg2_str;
72136   {
72137     try {
72138       (arg1)->SetImage((std::string const &)*arg2);
72139     } catch (std::out_of_range& e) {
72140       {
72141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72142       };
72143     } catch (std::exception& e) {
72144       {
72145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72146       };
72147     } catch (Dali::DaliException e) {
72148       {
72149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72150       };
72151     } catch (...) {
72152       {
72153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72154       };
72155     }
72156   }
72157
72158
72159   //argout typemap for const std::string&
72160
72161 }
72162
72163
72164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
72165   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72166   std::string *arg2 = 0 ;
72167   Dali::ImageDimensions arg3 ;
72168   Dali::ImageDimensions *argp3 ;
72169
72170   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72171   if (!jarg2) {
72172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72173     return ;
72174   }
72175   std::string arg2_str(jarg2);
72176   arg2 = &arg2_str;
72177   argp3 = (Dali::ImageDimensions *)jarg3;
72178   if (!argp3) {
72179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
72180     return ;
72181   }
72182   arg3 = *argp3;
72183   {
72184     try {
72185       (arg1)->SetImage((std::string const &)*arg2,arg3);
72186     } catch (std::out_of_range& e) {
72187       {
72188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72189       };
72190     } catch (std::exception& e) {
72191       {
72192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72193       };
72194     } catch (Dali::DaliException e) {
72195       {
72196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72197       };
72198     } catch (...) {
72199       {
72200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72201       };
72202     }
72203   }
72204
72205
72206   //argout typemap for const std::string&
72207
72208 }
72209
72210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
72211   void * jresult ;
72212   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72213   Dali::Image result;
72214
72215   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72216   {
72217     try {
72218       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
72219     } catch (std::out_of_range& e) {
72220       {
72221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72222       };
72223     } catch (std::exception& e) {
72224       {
72225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72226       };
72227     } catch (Dali::DaliException e) {
72228       {
72229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72230       };
72231     } catch (...) {
72232       {
72233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72234       };
72235     }
72236   }
72237
72238   jresult = new Dali::Image((const Dali::Image &)result);
72239   return jresult;
72240 }
72241
72242
72243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
72244   int jresult ;
72245   int result;
72246
72247   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
72248   jresult = (int)result;
72249   return jresult;
72250 }
72251
72252
72253 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
72254   int jresult ;
72255   int result;
72256
72257   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
72258   jresult = (int)result;
72259   return jresult;
72260 }
72261
72262
72263 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
72264   int jresult ;
72265   int result;
72266
72267   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
72268   jresult = (int)result;
72269   return jresult;
72270 }
72271
72272
72273 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
72274   int jresult ;
72275   int result;
72276
72277   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
72278   jresult = (int)result;
72279   return jresult;
72280 }
72281
72282
72283 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
72284   int jresult ;
72285   int result;
72286
72287   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
72288   jresult = (int)result;
72289   return jresult;
72290 }
72291
72292
72293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
72294   int jresult ;
72295   int result;
72296
72297   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
72298   jresult = (int)result;
72299   return jresult;
72300 }
72301
72302
72303 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
72304   int jresult ;
72305   int result;
72306
72307   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
72308   jresult = (int)result;
72309   return jresult;
72310 }
72311
72312
72313 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
72314   int jresult ;
72315   int result;
72316
72317   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
72318   jresult = (int)result;
72319   return jresult;
72320 }
72321
72322
72323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
72324   void * jresult ;
72325   Dali::Toolkit::Model3dView::Property *result = 0 ;
72326
72327   {
72328     try {
72329       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
72330     } catch (std::out_of_range& e) {
72331       {
72332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72333       };
72334     } catch (std::exception& e) {
72335       {
72336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72337       };
72338     } catch (Dali::DaliException e) {
72339       {
72340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72341       };
72342     } catch (...) {
72343       {
72344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72345       };
72346     }
72347   }
72348
72349   jresult = (void *)result;
72350   return jresult;
72351 }
72352
72353
72354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
72355   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
72356
72357   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
72358   {
72359     try {
72360       delete arg1;
72361     } catch (std::out_of_range& e) {
72362       {
72363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72364       };
72365     } catch (std::exception& e) {
72366       {
72367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72368       };
72369     } catch (Dali::DaliException e) {
72370       {
72371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72372       };
72373     } catch (...) {
72374       {
72375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72376       };
72377     }
72378   }
72379
72380 }
72381
72382
72383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
72384   void * jresult ;
72385   Dali::Toolkit::Model3dView result;
72386
72387   {
72388     try {
72389       result = Dali::Toolkit::Model3dView::New();
72390     } catch (std::out_of_range& e) {
72391       {
72392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72393       };
72394     } catch (std::exception& e) {
72395       {
72396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72397       };
72398     } catch (Dali::DaliException e) {
72399       {
72400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72401       };
72402     } catch (...) {
72403       {
72404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72405       };
72406     }
72407   }
72408
72409   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72410   return jresult;
72411 }
72412
72413
72414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
72415   void * jresult ;
72416   std::string *arg1 = 0 ;
72417   std::string *arg2 = 0 ;
72418   std::string *arg3 = 0 ;
72419   Dali::Toolkit::Model3dView result;
72420
72421   if (!jarg1) {
72422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72423     return 0;
72424   }
72425   std::string arg1_str(jarg1);
72426   arg1 = &arg1_str;
72427   if (!jarg2) {
72428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72429     return 0;
72430   }
72431   std::string arg2_str(jarg2);
72432   arg2 = &arg2_str;
72433   if (!jarg3) {
72434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72435     return 0;
72436   }
72437   std::string arg3_str(jarg3);
72438   arg3 = &arg3_str;
72439   {
72440     try {
72441       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
72442     } catch (std::out_of_range& e) {
72443       {
72444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72445       };
72446     } catch (std::exception& e) {
72447       {
72448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72449       };
72450     } catch (Dali::DaliException e) {
72451       {
72452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72453       };
72454     } catch (...) {
72455       {
72456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72457       };
72458     }
72459   }
72460
72461   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72462
72463   //argout typemap for const std::string&
72464
72465
72466   //argout typemap for const std::string&
72467
72468
72469   //argout typemap for const std::string&
72470
72471   return jresult;
72472 }
72473
72474
72475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
72476   void * jresult ;
72477   Dali::Toolkit::Model3dView *result = 0 ;
72478
72479   {
72480     try {
72481       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
72482     } catch (std::out_of_range& e) {
72483       {
72484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72485       };
72486     } catch (std::exception& e) {
72487       {
72488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72489       };
72490     } catch (Dali::DaliException e) {
72491       {
72492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72493       };
72494     } catch (...) {
72495       {
72496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72497       };
72498     }
72499   }
72500
72501   jresult = (void *)result;
72502   return jresult;
72503 }
72504
72505
72506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
72507   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72508
72509   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72510   {
72511     try {
72512       delete arg1;
72513     } catch (std::out_of_range& e) {
72514       {
72515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72516       };
72517     } catch (std::exception& e) {
72518       {
72519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72520       };
72521     } catch (Dali::DaliException e) {
72522       {
72523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72524       };
72525     } catch (...) {
72526       {
72527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72528       };
72529     }
72530   }
72531
72532 }
72533
72534
72535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
72536   void * jresult ;
72537   Dali::Toolkit::Model3dView *arg1 = 0 ;
72538   Dali::Toolkit::Model3dView *result = 0 ;
72539
72540   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72541   if (!arg1) {
72542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
72543     return 0;
72544   }
72545   {
72546     try {
72547       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
72548     } catch (std::out_of_range& e) {
72549       {
72550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72551       };
72552     } catch (std::exception& e) {
72553       {
72554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72555       };
72556     } catch (Dali::DaliException e) {
72557       {
72558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72559       };
72560     } catch (...) {
72561       {
72562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72563       };
72564     }
72565   }
72566
72567   jresult = (void *)result;
72568   return jresult;
72569 }
72570
72571
72572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
72573   void * jresult ;
72574   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72575   Dali::Toolkit::Model3dView *arg2 = 0 ;
72576   Dali::Toolkit::Model3dView *result = 0 ;
72577
72578   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72579   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
72580   if (!arg2) {
72581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
72582     return 0;
72583   }
72584   {
72585     try {
72586       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
72587     } catch (std::out_of_range& e) {
72588       {
72589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72590       };
72591     } catch (std::exception& e) {
72592       {
72593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72594       };
72595     } catch (Dali::DaliException e) {
72596       {
72597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72598       };
72599     } catch (...) {
72600       {
72601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72602       };
72603     }
72604   }
72605
72606   jresult = (void *)result;
72607   return jresult;
72608 }
72609
72610
72611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
72612   void * jresult ;
72613   Dali::BaseHandle arg1 ;
72614   Dali::BaseHandle *argp1 ;
72615   Dali::Toolkit::Model3dView result;
72616
72617   argp1 = (Dali::BaseHandle *)jarg1;
72618   if (!argp1) {
72619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72620     return 0;
72621   }
72622   arg1 = *argp1;
72623   {
72624     try {
72625       result = Dali::Toolkit::Model3dView::DownCast(arg1);
72626     } catch (std::out_of_range& e) {
72627       {
72628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72629       };
72630     } catch (std::exception& e) {
72631       {
72632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72633       };
72634     } catch (Dali::DaliException e) {
72635       {
72636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72637       };
72638     } catch (...) {
72639       {
72640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72641       };
72642     }
72643   }
72644
72645   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72646   return jresult;
72647 }
72648
72649
72650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
72651   int jresult ;
72652   int result;
72653
72654   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
72655   jresult = (int)result;
72656   return jresult;
72657 }
72658
72659
72660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
72661   int jresult ;
72662   int result;
72663
72664   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
72665   jresult = (int)result;
72666   return jresult;
72667 }
72668
72669
72670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
72671   int jresult ;
72672   int result;
72673
72674   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
72675   jresult = (int)result;
72676   return jresult;
72677 }
72678
72679
72680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
72681   int jresult ;
72682   int result;
72683
72684   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
72685   jresult = (int)result;
72686   return jresult;
72687 }
72688
72689
72690 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
72691   int jresult ;
72692   int result;
72693
72694   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
72695   jresult = (int)result;
72696   return jresult;
72697 }
72698
72699
72700 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
72701   int jresult ;
72702   int result;
72703
72704   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
72705   jresult = (int)result;
72706   return jresult;
72707 }
72708
72709
72710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
72711   int jresult ;
72712   int result;
72713
72714   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
72715   jresult = (int)result;
72716   return jresult;
72717 }
72718
72719
72720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
72721   int jresult ;
72722   int result;
72723
72724   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
72725   jresult = (int)result;
72726   return jresult;
72727 }
72728
72729
72730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
72731   int jresult ;
72732   int result;
72733
72734   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
72735   jresult = (int)result;
72736   return jresult;
72737 }
72738
72739
72740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
72741   void * jresult ;
72742   Dali::Toolkit::ScrollBar::Property *result = 0 ;
72743
72744   {
72745     try {
72746       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
72747     } catch (std::out_of_range& e) {
72748       {
72749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72750       };
72751     } catch (std::exception& e) {
72752       {
72753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72754       };
72755     } catch (Dali::DaliException e) {
72756       {
72757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72758       };
72759     } catch (...) {
72760       {
72761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72762       };
72763     }
72764   }
72765
72766   jresult = (void *)result;
72767   return jresult;
72768 }
72769
72770
72771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
72772   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
72773
72774   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
72775   {
72776     try {
72777       delete arg1;
72778     } catch (std::out_of_range& e) {
72779       {
72780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72781       };
72782     } catch (std::exception& e) {
72783       {
72784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72785       };
72786     } catch (Dali::DaliException e) {
72787       {
72788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72789       };
72790     } catch (...) {
72791       {
72792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72793       };
72794     }
72795   }
72796
72797 }
72798
72799
72800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
72801   void * jresult ;
72802   Dali::Toolkit::ScrollBar *result = 0 ;
72803
72804   {
72805     try {
72806       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
72807     } catch (std::out_of_range& e) {
72808       {
72809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72810       };
72811     } catch (std::exception& e) {
72812       {
72813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72814       };
72815     } catch (Dali::DaliException e) {
72816       {
72817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72818       };
72819     } catch (...) {
72820       {
72821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72822       };
72823     }
72824   }
72825
72826   jresult = (void *)result;
72827   return jresult;
72828 }
72829
72830
72831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
72832   void * jresult ;
72833   Dali::Toolkit::ScrollBar *arg1 = 0 ;
72834   Dali::Toolkit::ScrollBar *result = 0 ;
72835
72836   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72837   if (!arg1) {
72838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
72839     return 0;
72840   }
72841   {
72842     try {
72843       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
72844     } catch (std::out_of_range& e) {
72845       {
72846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72847       };
72848     } catch (std::exception& e) {
72849       {
72850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72851       };
72852     } catch (Dali::DaliException e) {
72853       {
72854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72855       };
72856     } catch (...) {
72857       {
72858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72859       };
72860     }
72861   }
72862
72863   jresult = (void *)result;
72864   return jresult;
72865 }
72866
72867
72868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
72869   void * jresult ;
72870   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72871   Dali::Toolkit::ScrollBar *arg2 = 0 ;
72872   Dali::Toolkit::ScrollBar *result = 0 ;
72873
72874   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72875   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
72876   if (!arg2) {
72877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
72878     return 0;
72879   }
72880   {
72881     try {
72882       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
72883     } catch (std::out_of_range& e) {
72884       {
72885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72886       };
72887     } catch (std::exception& e) {
72888       {
72889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72890       };
72891     } catch (Dali::DaliException e) {
72892       {
72893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72894       };
72895     } catch (...) {
72896       {
72897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72898       };
72899     }
72900   }
72901
72902   jresult = (void *)result;
72903   return jresult;
72904 }
72905
72906
72907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
72908   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72909
72910   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72911   {
72912     try {
72913       delete arg1;
72914     } catch (std::out_of_range& e) {
72915       {
72916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72917       };
72918     } catch (std::exception& e) {
72919       {
72920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72921       };
72922     } catch (Dali::DaliException e) {
72923       {
72924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72925       };
72926     } catch (...) {
72927       {
72928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72929       };
72930     }
72931   }
72932
72933 }
72934
72935
72936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
72937   void * jresult ;
72938   Dali::Toolkit::ScrollBar::Direction arg1 ;
72939   Dali::Toolkit::ScrollBar result;
72940
72941   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
72942   {
72943     try {
72944       result = Dali::Toolkit::ScrollBar::New(arg1);
72945     } catch (std::out_of_range& e) {
72946       {
72947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72948       };
72949     } catch (std::exception& e) {
72950       {
72951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72952       };
72953     } catch (Dali::DaliException e) {
72954       {
72955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72956       };
72957     } catch (...) {
72958       {
72959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72960       };
72961     }
72962   }
72963
72964   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
72965   return jresult;
72966 }
72967
72968
72969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
72970   void * jresult ;
72971   Dali::Toolkit::ScrollBar result;
72972
72973   {
72974     try {
72975       result = Dali::Toolkit::ScrollBar::New();
72976     } catch (std::out_of_range& e) {
72977       {
72978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72979       };
72980     } catch (std::exception& e) {
72981       {
72982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72983       };
72984     } catch (Dali::DaliException e) {
72985       {
72986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72987       };
72988     } catch (...) {
72989       {
72990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72991       };
72992     }
72993   }
72994
72995   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
72996   return jresult;
72997 }
72998
72999
73000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
73001   void * jresult ;
73002   Dali::BaseHandle arg1 ;
73003   Dali::BaseHandle *argp1 ;
73004   Dali::Toolkit::ScrollBar result;
73005
73006   argp1 = (Dali::BaseHandle *)jarg1;
73007   if (!argp1) {
73008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73009     return 0;
73010   }
73011   arg1 = *argp1;
73012   {
73013     try {
73014       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
73015     } catch (std::out_of_range& e) {
73016       {
73017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73018       };
73019     } catch (std::exception& e) {
73020       {
73021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73022       };
73023     } catch (Dali::DaliException e) {
73024       {
73025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73026       };
73027     } catch (...) {
73028       {
73029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73030       };
73031     }
73032   }
73033
73034   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73035   return jresult;
73036 }
73037
73038
73039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
73040   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73041   Dali::Handle arg2 ;
73042   Dali::Property::Index arg3 ;
73043   Dali::Property::Index arg4 ;
73044   Dali::Property::Index arg5 ;
73045   Dali::Property::Index arg6 ;
73046   Dali::Handle *argp2 ;
73047
73048   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73049   argp2 = (Dali::Handle *)jarg2;
73050   if (!argp2) {
73051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
73052     return ;
73053   }
73054   arg2 = *argp2;
73055   arg3 = (Dali::Property::Index)jarg3;
73056   arg4 = (Dali::Property::Index)jarg4;
73057   arg5 = (Dali::Property::Index)jarg5;
73058   arg6 = (Dali::Property::Index)jarg6;
73059   {
73060     try {
73061       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
73062     } catch (std::out_of_range& e) {
73063       {
73064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73065       };
73066     } catch (std::exception& e) {
73067       {
73068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73069       };
73070     } catch (Dali::DaliException e) {
73071       {
73072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73073       };
73074     } catch (...) {
73075       {
73076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73077       };
73078     }
73079   }
73080
73081 }
73082
73083
73084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
73085   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73086   Dali::Actor arg2 ;
73087   Dali::Actor *argp2 ;
73088
73089   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73090   argp2 = (Dali::Actor *)jarg2;
73091   if (!argp2) {
73092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73093     return ;
73094   }
73095   arg2 = *argp2;
73096   {
73097     try {
73098       (arg1)->SetScrollIndicator(arg2);
73099     } catch (std::out_of_range& e) {
73100       {
73101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73102       };
73103     } catch (std::exception& e) {
73104       {
73105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73106       };
73107     } catch (Dali::DaliException e) {
73108       {
73109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73110       };
73111     } catch (...) {
73112       {
73113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73114       };
73115     }
73116   }
73117
73118 }
73119
73120
73121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
73122   void * jresult ;
73123   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73124   Dali::Actor result;
73125
73126   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73127   {
73128     try {
73129       result = (arg1)->GetScrollIndicator();
73130     } catch (std::out_of_range& e) {
73131       {
73132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73133       };
73134     } catch (std::exception& e) {
73135       {
73136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73137       };
73138     } catch (Dali::DaliException e) {
73139       {
73140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73141       };
73142     } catch (...) {
73143       {
73144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73145       };
73146     }
73147   }
73148
73149   jresult = new Dali::Actor((const Dali::Actor &)result);
73150   return jresult;
73151 }
73152
73153
73154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
73155   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73156   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
73157
73158   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73159   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
73160   if (!arg2) {
73161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
73162     return ;
73163   }
73164   {
73165     try {
73166       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
73167     } catch (std::out_of_range& e) {
73168       {
73169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73170       };
73171     } catch (std::exception& e) {
73172       {
73173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73174       };
73175     } catch (Dali::DaliException e) {
73176       {
73177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73178       };
73179     } catch (...) {
73180       {
73181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73182       };
73183     }
73184   }
73185
73186 }
73187
73188
73189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
73190   void * jresult ;
73191   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73192
73193   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73194   {
73195     try {
73196       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()));
73197     } catch (std::out_of_range& e) {
73198       {
73199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73200       };
73201     } catch (std::exception& e) {
73202       {
73203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73204       };
73205     } catch (...) {
73206       {
73207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73208       };
73209     }
73210   }
73211   return jresult;
73212 }
73213
73214
73215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
73216   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73217   Dali::Toolkit::ScrollBar::Direction arg2 ;
73218
73219   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73220   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
73221   {
73222     try {
73223       (arg1)->SetScrollDirection(arg2);
73224     } catch (std::out_of_range& e) {
73225       {
73226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73227       };
73228     } catch (std::exception& e) {
73229       {
73230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73231       };
73232     } catch (Dali::DaliException e) {
73233       {
73234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73235       };
73236     } catch (...) {
73237       {
73238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73239       };
73240     }
73241   }
73242
73243 }
73244
73245
73246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
73247   int jresult ;
73248   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73249   Dali::Toolkit::ScrollBar::Direction result;
73250
73251   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73252   {
73253     try {
73254       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
73255     } catch (std::out_of_range& e) {
73256       {
73257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73258       };
73259     } catch (std::exception& e) {
73260       {
73261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73262       };
73263     } catch (Dali::DaliException e) {
73264       {
73265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73266       };
73267     } catch (...) {
73268       {
73269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73270       };
73271     }
73272   }
73273
73274   jresult = (int)result;
73275   return jresult;
73276 }
73277
73278
73279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
73280   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73281   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
73282
73283   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73284   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
73285   {
73286     try {
73287       (arg1)->SetIndicatorHeightPolicy(arg2);
73288     } catch (std::out_of_range& e) {
73289       {
73290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73291       };
73292     } catch (std::exception& e) {
73293       {
73294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73295       };
73296     } catch (Dali::DaliException e) {
73297       {
73298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73299       };
73300     } catch (...) {
73301       {
73302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73303       };
73304     }
73305   }
73306
73307 }
73308
73309
73310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
73311   int jresult ;
73312   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73313   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
73314
73315   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73316   {
73317     try {
73318       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
73319     } catch (std::out_of_range& e) {
73320       {
73321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73322       };
73323     } catch (std::exception& e) {
73324       {
73325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73326       };
73327     } catch (Dali::DaliException e) {
73328       {
73329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73330       };
73331     } catch (...) {
73332       {
73333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73334       };
73335     }
73336   }
73337
73338   jresult = (int)result;
73339   return jresult;
73340 }
73341
73342
73343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
73344   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73345   float arg2 ;
73346
73347   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73348   arg2 = (float)jarg2;
73349   {
73350     try {
73351       (arg1)->SetIndicatorFixedHeight(arg2);
73352     } catch (std::out_of_range& e) {
73353       {
73354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73355       };
73356     } catch (std::exception& e) {
73357       {
73358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73359       };
73360     } catch (Dali::DaliException e) {
73361       {
73362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73363       };
73364     } catch (...) {
73365       {
73366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73367       };
73368     }
73369   }
73370
73371 }
73372
73373
73374 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
73375   float jresult ;
73376   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73377   float result;
73378
73379   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73380   {
73381     try {
73382       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
73383     } catch (std::out_of_range& e) {
73384       {
73385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73386       };
73387     } catch (std::exception& e) {
73388       {
73389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73390       };
73391     } catch (Dali::DaliException e) {
73392       {
73393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73394       };
73395     } catch (...) {
73396       {
73397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73398       };
73399     }
73400   }
73401
73402   jresult = result;
73403   return jresult;
73404 }
73405
73406
73407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
73408   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73409   float arg2 ;
73410
73411   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73412   arg2 = (float)jarg2;
73413   {
73414     try {
73415       (arg1)->SetIndicatorShowDuration(arg2);
73416     } catch (std::out_of_range& e) {
73417       {
73418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73419       };
73420     } catch (std::exception& e) {
73421       {
73422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73423       };
73424     } catch (Dali::DaliException e) {
73425       {
73426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73427       };
73428     } catch (...) {
73429       {
73430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73431       };
73432     }
73433   }
73434
73435 }
73436
73437
73438 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
73439   float jresult ;
73440   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73441   float result;
73442
73443   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73444   {
73445     try {
73446       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
73447     } catch (std::out_of_range& e) {
73448       {
73449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73450       };
73451     } catch (std::exception& e) {
73452       {
73453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73454       };
73455     } catch (Dali::DaliException e) {
73456       {
73457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73458       };
73459     } catch (...) {
73460       {
73461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73462       };
73463     }
73464   }
73465
73466   jresult = result;
73467   return jresult;
73468 }
73469
73470
73471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
73472   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73473   float arg2 ;
73474
73475   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73476   arg2 = (float)jarg2;
73477   {
73478     try {
73479       (arg1)->SetIndicatorHideDuration(arg2);
73480     } catch (std::out_of_range& e) {
73481       {
73482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73483       };
73484     } catch (std::exception& e) {
73485       {
73486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73487       };
73488     } catch (Dali::DaliException e) {
73489       {
73490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73491       };
73492     } catch (...) {
73493       {
73494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73495       };
73496     }
73497   }
73498
73499 }
73500
73501
73502 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
73503   float jresult ;
73504   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73505   float result;
73506
73507   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73508   {
73509     try {
73510       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
73511     } catch (std::out_of_range& e) {
73512       {
73513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73514       };
73515     } catch (std::exception& e) {
73516       {
73517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73518       };
73519     } catch (Dali::DaliException e) {
73520       {
73521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73522       };
73523     } catch (...) {
73524       {
73525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73526       };
73527     }
73528   }
73529
73530   jresult = result;
73531   return jresult;
73532 }
73533
73534
73535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
73536   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73537
73538   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73539   {
73540     try {
73541       (arg1)->ShowIndicator();
73542     } catch (std::out_of_range& e) {
73543       {
73544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73545       };
73546     } catch (std::exception& e) {
73547       {
73548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73549       };
73550     } catch (Dali::DaliException e) {
73551       {
73552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73553       };
73554     } catch (...) {
73555       {
73556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73557       };
73558     }
73559   }
73560
73561 }
73562
73563
73564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
73565   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73566
73567   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73568   {
73569     try {
73570       (arg1)->HideIndicator();
73571     } catch (std::out_of_range& e) {
73572       {
73573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73574       };
73575     } catch (std::exception& e) {
73576       {
73577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73578       };
73579     } catch (Dali::DaliException e) {
73580       {
73581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73582       };
73583     } catch (...) {
73584       {
73585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73586       };
73587     }
73588   }
73589
73590 }
73591
73592
73593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
73594   void * jresult ;
73595   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73596   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
73597
73598   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73599   {
73600     try {
73601       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
73602     } catch (std::out_of_range& e) {
73603       {
73604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73605       };
73606     } catch (std::exception& e) {
73607       {
73608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73609       };
73610     } catch (Dali::DaliException e) {
73611       {
73612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73613       };
73614     } catch (...) {
73615       {
73616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73617       };
73618     }
73619   }
73620
73621   jresult = (void *)result;
73622   return jresult;
73623 }
73624
73625
73626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
73627   void * jresult ;
73628   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73629   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
73630
73631   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73632   {
73633     try {
73634       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
73635     } catch (std::out_of_range& e) {
73636       {
73637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73638       };
73639     } catch (std::exception& e) {
73640       {
73641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73642       };
73643     } catch (Dali::DaliException e) {
73644       {
73645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73646       };
73647     } catch (...) {
73648       {
73649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73650       };
73651     }
73652   }
73653
73654   jresult = (void *)result;
73655   return jresult;
73656 }
73657
73658
73659 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
73660   int jresult ;
73661   int result;
73662
73663   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
73664   jresult = (int)result;
73665   return jresult;
73666 }
73667
73668
73669 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
73670   int jresult ;
73671   int result;
73672
73673   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
73674   jresult = (int)result;
73675   return jresult;
73676 }
73677
73678
73679 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
73680   int jresult ;
73681   int result;
73682
73683   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
73684   jresult = (int)result;
73685   return jresult;
73686 }
73687
73688
73689 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
73690   int jresult ;
73691   int result;
73692
73693   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
73694   jresult = (int)result;
73695   return jresult;
73696 }
73697
73698
73699 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
73700   int jresult ;
73701   int result;
73702
73703   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
73704   jresult = (int)result;
73705   return jresult;
73706 }
73707
73708
73709 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
73710   int jresult ;
73711   int result;
73712
73713   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
73714   jresult = (int)result;
73715   return jresult;
73716 }
73717
73718
73719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
73720   int jresult ;
73721   int result;
73722
73723   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
73724   jresult = (int)result;
73725   return jresult;
73726 }
73727
73728
73729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
73730   int jresult ;
73731   int result;
73732
73733   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
73734   jresult = (int)result;
73735   return jresult;
73736 }
73737
73738
73739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
73740   int jresult ;
73741   int result;
73742
73743   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
73744   jresult = (int)result;
73745   return jresult;
73746 }
73747
73748
73749 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
73750   int jresult ;
73751   int result;
73752
73753   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
73754   jresult = (int)result;
73755   return jresult;
73756 }
73757
73758
73759 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
73760   int jresult ;
73761   int result;
73762
73763   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
73764   jresult = (int)result;
73765   return jresult;
73766 }
73767
73768
73769 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
73770   int jresult ;
73771   int result;
73772
73773   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
73774   jresult = (int)result;
73775   return jresult;
73776 }
73777
73778
73779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
73780   int jresult ;
73781   int result;
73782
73783   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
73784   jresult = (int)result;
73785   return jresult;
73786 }
73787
73788
73789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
73790   int jresult ;
73791   int result;
73792
73793   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
73794   jresult = (int)result;
73795   return jresult;
73796 }
73797
73798
73799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
73800   void * jresult ;
73801   Dali::Toolkit::Scrollable::Property *result = 0 ;
73802
73803   {
73804     try {
73805       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
73806     } catch (std::out_of_range& e) {
73807       {
73808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73809       };
73810     } catch (std::exception& e) {
73811       {
73812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73813       };
73814     } catch (Dali::DaliException e) {
73815       {
73816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73817       };
73818     } catch (...) {
73819       {
73820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73821       };
73822     }
73823   }
73824
73825   jresult = (void *)result;
73826   return jresult;
73827 }
73828
73829
73830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
73831   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
73832
73833   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
73834   {
73835     try {
73836       delete arg1;
73837     } catch (std::out_of_range& e) {
73838       {
73839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73840       };
73841     } catch (std::exception& e) {
73842       {
73843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73844       };
73845     } catch (Dali::DaliException e) {
73846       {
73847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73848       };
73849     } catch (...) {
73850       {
73851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73852       };
73853     }
73854   }
73855
73856 }
73857
73858
73859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
73860   void * jresult ;
73861   Dali::Toolkit::Scrollable *result = 0 ;
73862
73863   {
73864     try {
73865       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
73866     } catch (std::out_of_range& e) {
73867       {
73868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73869       };
73870     } catch (std::exception& e) {
73871       {
73872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73873       };
73874     } catch (Dali::DaliException e) {
73875       {
73876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73877       };
73878     } catch (...) {
73879       {
73880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73881       };
73882     }
73883   }
73884
73885   jresult = (void *)result;
73886   return jresult;
73887 }
73888
73889
73890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
73891   void * jresult ;
73892   Dali::Toolkit::Scrollable *arg1 = 0 ;
73893   Dali::Toolkit::Scrollable *result = 0 ;
73894
73895   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73896   if (!arg1) {
73897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
73898     return 0;
73899   }
73900   {
73901     try {
73902       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
73903     } catch (std::out_of_range& e) {
73904       {
73905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73906       };
73907     } catch (std::exception& e) {
73908       {
73909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73910       };
73911     } catch (Dali::DaliException e) {
73912       {
73913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73914       };
73915     } catch (...) {
73916       {
73917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73918       };
73919     }
73920   }
73921
73922   jresult = (void *)result;
73923   return jresult;
73924 }
73925
73926
73927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
73928   void * jresult ;
73929   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73930   Dali::Toolkit::Scrollable *arg2 = 0 ;
73931   Dali::Toolkit::Scrollable *result = 0 ;
73932
73933   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73934   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
73935   if (!arg2) {
73936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
73937     return 0;
73938   }
73939   {
73940     try {
73941       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
73942     } catch (std::out_of_range& e) {
73943       {
73944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73945       };
73946     } catch (std::exception& e) {
73947       {
73948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73949       };
73950     } catch (Dali::DaliException e) {
73951       {
73952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73953       };
73954     } catch (...) {
73955       {
73956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73957       };
73958     }
73959   }
73960
73961   jresult = (void *)result;
73962   return jresult;
73963 }
73964
73965
73966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
73967   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73968
73969   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73970   {
73971     try {
73972       delete arg1;
73973     } catch (std::out_of_range& e) {
73974       {
73975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73976       };
73977     } catch (std::exception& e) {
73978       {
73979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73980       };
73981     } catch (Dali::DaliException e) {
73982       {
73983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73984       };
73985     } catch (...) {
73986       {
73987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73988       };
73989     }
73990   }
73991
73992 }
73993
73994
73995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
73996   void * jresult ;
73997   Dali::BaseHandle arg1 ;
73998   Dali::BaseHandle *argp1 ;
73999   Dali::Toolkit::Scrollable result;
74000
74001   argp1 = (Dali::BaseHandle *)jarg1;
74002   if (!argp1) {
74003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74004     return 0;
74005   }
74006   arg1 = *argp1;
74007   {
74008     try {
74009       result = Dali::Toolkit::Scrollable::DownCast(arg1);
74010     } catch (std::out_of_range& e) {
74011       {
74012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74013       };
74014     } catch (std::exception& e) {
74015       {
74016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74017       };
74018     } catch (Dali::DaliException e) {
74019       {
74020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74021       };
74022     } catch (...) {
74023       {
74024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74025       };
74026     }
74027   }
74028
74029   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
74030   return jresult;
74031 }
74032
74033
74034 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
74035   unsigned int jresult ;
74036   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74037   bool result;
74038
74039   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74040   {
74041     try {
74042       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
74043     } catch (std::out_of_range& e) {
74044       {
74045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74046       };
74047     } catch (std::exception& e) {
74048       {
74049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74050       };
74051     } catch (Dali::DaliException e) {
74052       {
74053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74054       };
74055     } catch (...) {
74056       {
74057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74058       };
74059     }
74060   }
74061
74062   jresult = result;
74063   return jresult;
74064 }
74065
74066
74067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
74068   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74069   bool arg2 ;
74070
74071   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74072   arg2 = jarg2 ? true : false;
74073   {
74074     try {
74075       (arg1)->SetOvershootEnabled(arg2);
74076     } catch (std::out_of_range& e) {
74077       {
74078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74079       };
74080     } catch (std::exception& e) {
74081       {
74082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74083       };
74084     } catch (Dali::DaliException e) {
74085       {
74086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74087       };
74088     } catch (...) {
74089       {
74090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74091       };
74092     }
74093   }
74094
74095 }
74096
74097
74098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
74099   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74100   Dali::Vector4 *arg2 = 0 ;
74101
74102   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74103   arg2 = (Dali::Vector4 *)jarg2;
74104   if (!arg2) {
74105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
74106     return ;
74107   }
74108   {
74109     try {
74110       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
74111     } catch (std::out_of_range& e) {
74112       {
74113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74114       };
74115     } catch (std::exception& e) {
74116       {
74117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74118       };
74119     } catch (Dali::DaliException e) {
74120       {
74121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74122       };
74123     } catch (...) {
74124       {
74125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74126       };
74127     }
74128   }
74129
74130 }
74131
74132
74133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
74134   void * jresult ;
74135   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74136   Dali::Vector4 result;
74137
74138   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74139   {
74140     try {
74141       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
74142     } catch (std::out_of_range& e) {
74143       {
74144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74145       };
74146     } catch (std::exception& e) {
74147       {
74148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74149       };
74150     } catch (Dali::DaliException e) {
74151       {
74152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74153       };
74154     } catch (...) {
74155       {
74156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74157       };
74158     }
74159   }
74160
74161   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
74162   return jresult;
74163 }
74164
74165
74166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
74167   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74168   float arg2 ;
74169
74170   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74171   arg2 = (float)jarg2;
74172   {
74173     try {
74174       (arg1)->SetOvershootAnimationSpeed(arg2);
74175     } catch (std::out_of_range& e) {
74176       {
74177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74178       };
74179     } catch (std::exception& e) {
74180       {
74181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74182       };
74183     } catch (Dali::DaliException e) {
74184       {
74185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74186       };
74187     } catch (...) {
74188       {
74189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74190       };
74191     }
74192   }
74193
74194 }
74195
74196
74197 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
74198   float jresult ;
74199   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74200   float result;
74201
74202   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74203   {
74204     try {
74205       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
74206     } catch (std::out_of_range& e) {
74207       {
74208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74209       };
74210     } catch (std::exception& e) {
74211       {
74212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74213       };
74214     } catch (Dali::DaliException e) {
74215       {
74216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74217       };
74218     } catch (...) {
74219       {
74220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74221       };
74222     }
74223   }
74224
74225   jresult = result;
74226   return jresult;
74227 }
74228
74229
74230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
74231   void * jresult ;
74232   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74233   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
74234
74235   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74236   {
74237     try {
74238       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
74239     } catch (std::out_of_range& e) {
74240       {
74241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74242       };
74243     } catch (std::exception& e) {
74244       {
74245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74246       };
74247     } catch (Dali::DaliException e) {
74248       {
74249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74250       };
74251     } catch (...) {
74252       {
74253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74254       };
74255     }
74256   }
74257
74258   jresult = (void *)result;
74259   return jresult;
74260 }
74261
74262
74263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
74264   void * jresult ;
74265   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74266   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
74267
74268   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74269   {
74270     try {
74271       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
74272     } catch (std::out_of_range& e) {
74273       {
74274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74275       };
74276     } catch (std::exception& e) {
74277       {
74278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74279       };
74280     } catch (Dali::DaliException e) {
74281       {
74282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74283       };
74284     } catch (...) {
74285       {
74286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74287       };
74288     }
74289   }
74290
74291   jresult = (void *)result;
74292   return jresult;
74293 }
74294
74295
74296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
74297   void * jresult ;
74298   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74299   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
74300
74301   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74302   {
74303     try {
74304       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
74305     } catch (std::out_of_range& e) {
74306       {
74307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74308       };
74309     } catch (std::exception& e) {
74310       {
74311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74312       };
74313     } catch (Dali::DaliException e) {
74314       {
74315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74316       };
74317     } catch (...) {
74318       {
74319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74320       };
74321     }
74322   }
74323
74324   jresult = (void *)result;
74325   return jresult;
74326 }
74327
74328
74329 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
74330   unsigned int jresult ;
74331   Dali::Toolkit::ControlOrientation::Type arg1 ;
74332   bool result;
74333
74334   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74335   {
74336     try {
74337       result = (bool)Dali::Toolkit::IsVertical(arg1);
74338     } catch (std::out_of_range& e) {
74339       {
74340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74341       };
74342     } catch (std::exception& e) {
74343       {
74344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74345       };
74346     } catch (Dali::DaliException e) {
74347       {
74348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74349       };
74350     } catch (...) {
74351       {
74352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74353       };
74354     }
74355   }
74356
74357   jresult = result;
74358   return jresult;
74359 }
74360
74361
74362 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
74363   unsigned int jresult ;
74364   Dali::Toolkit::ControlOrientation::Type arg1 ;
74365   bool result;
74366
74367   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74368   {
74369     try {
74370       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
74371     } catch (std::out_of_range& e) {
74372       {
74373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74374       };
74375     } catch (std::exception& e) {
74376       {
74377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74378       };
74379     } catch (Dali::DaliException e) {
74380       {
74381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74382       };
74383     } catch (...) {
74384       {
74385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74386       };
74387     }
74388   }
74389
74390   jresult = result;
74391   return jresult;
74392 }
74393
74394
74395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
74396   void * jresult ;
74397   unsigned int arg1 ;
74398   unsigned int arg2 ;
74399   Dali::Toolkit::ItemRange *result = 0 ;
74400
74401   arg1 = (unsigned int)jarg1;
74402   arg2 = (unsigned int)jarg2;
74403   {
74404     try {
74405       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
74406     } catch (std::out_of_range& e) {
74407       {
74408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74409       };
74410     } catch (std::exception& e) {
74411       {
74412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74413       };
74414     } catch (Dali::DaliException e) {
74415       {
74416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74417       };
74418     } catch (...) {
74419       {
74420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74421       };
74422     }
74423   }
74424
74425   jresult = (void *)result;
74426   return jresult;
74427 }
74428
74429
74430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
74431   void * jresult ;
74432   Dali::Toolkit::ItemRange *arg1 = 0 ;
74433   Dali::Toolkit::ItemRange *result = 0 ;
74434
74435   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74436   if (!arg1) {
74437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74438     return 0;
74439   }
74440   {
74441     try {
74442       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
74443     } catch (std::out_of_range& e) {
74444       {
74445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74446       };
74447     } catch (std::exception& e) {
74448       {
74449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74450       };
74451     } catch (Dali::DaliException e) {
74452       {
74453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74454       };
74455     } catch (...) {
74456       {
74457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74458       };
74459     }
74460   }
74461
74462   jresult = (void *)result;
74463   return jresult;
74464 }
74465
74466
74467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
74468   void * jresult ;
74469   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74470   Dali::Toolkit::ItemRange *arg2 = 0 ;
74471   Dali::Toolkit::ItemRange *result = 0 ;
74472
74473   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74474   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74475   if (!arg2) {
74476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74477     return 0;
74478   }
74479   {
74480     try {
74481       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
74482     } catch (std::out_of_range& e) {
74483       {
74484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74485       };
74486     } catch (std::exception& e) {
74487       {
74488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74489       };
74490     } catch (Dali::DaliException e) {
74491       {
74492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74493       };
74494     } catch (...) {
74495       {
74496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74497       };
74498     }
74499   }
74500
74501   jresult = (void *)result;
74502   return jresult;
74503 }
74504
74505
74506 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
74507   unsigned int jresult ;
74508   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74509   unsigned int arg2 ;
74510   bool result;
74511
74512   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74513   arg2 = (unsigned int)jarg2;
74514   {
74515     try {
74516       result = (bool)(arg1)->Within(arg2);
74517     } catch (std::out_of_range& e) {
74518       {
74519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74520       };
74521     } catch (std::exception& e) {
74522       {
74523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74524       };
74525     } catch (Dali::DaliException e) {
74526       {
74527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74528       };
74529     } catch (...) {
74530       {
74531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74532       };
74533     }
74534   }
74535
74536   jresult = result;
74537   return jresult;
74538 }
74539
74540
74541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
74542   void * jresult ;
74543   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74544   Dali::Toolkit::ItemRange *arg2 = 0 ;
74545   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
74546
74547   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74548   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74549   if (!arg2) {
74550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74551     return 0;
74552   }
74553   {
74554     try {
74555       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
74556     } catch (std::out_of_range& e) {
74557       {
74558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74559       };
74560     } catch (std::exception& e) {
74561       {
74562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74563       };
74564     } catch (Dali::DaliException e) {
74565       {
74566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74567       };
74568     } catch (...) {
74569       {
74570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74571       };
74572     }
74573   }
74574
74575   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
74576   return jresult;
74577 }
74578
74579
74580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
74581   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74582   unsigned int arg2 ;
74583
74584   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74585   arg2 = (unsigned int)jarg2;
74586   if (arg1) (arg1)->begin = arg2;
74587 }
74588
74589
74590 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
74591   unsigned int jresult ;
74592   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74593   unsigned int result;
74594
74595   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74596   result = (unsigned int) ((arg1)->begin);
74597   jresult = result;
74598   return jresult;
74599 }
74600
74601
74602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
74603   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74604   unsigned int arg2 ;
74605
74606   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74607   arg2 = (unsigned int)jarg2;
74608   if (arg1) (arg1)->end = arg2;
74609 }
74610
74611
74612 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
74613   unsigned int jresult ;
74614   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74615   unsigned int result;
74616
74617   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74618   result = (unsigned int) ((arg1)->end);
74619   jresult = result;
74620   return jresult;
74621 }
74622
74623
74624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
74625   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74626
74627   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74628   {
74629     try {
74630       delete arg1;
74631     } catch (std::out_of_range& e) {
74632       {
74633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74634       };
74635     } catch (std::exception& e) {
74636       {
74637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74638       };
74639     } catch (Dali::DaliException e) {
74640       {
74641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74642       };
74643     } catch (...) {
74644       {
74645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74646       };
74647     }
74648   }
74649
74650 }
74651
74652
74653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
74654   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74655
74656   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74657   {
74658     try {
74659       delete arg1;
74660     } catch (std::out_of_range& e) {
74661       {
74662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74663       };
74664     } catch (std::exception& e) {
74665       {
74666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74667       };
74668     } catch (Dali::DaliException e) {
74669       {
74670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74671       };
74672     } catch (...) {
74673       {
74674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74675       };
74676     }
74677   }
74678
74679 }
74680
74681
74682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
74683   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74684   Dali::Toolkit::ControlOrientation::Type arg2 ;
74685
74686   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74687   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
74688   {
74689     try {
74690       (arg1)->SetOrientation(arg2);
74691     } catch (std::out_of_range& e) {
74692       {
74693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74694       };
74695     } catch (std::exception& e) {
74696       {
74697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74698       };
74699     } catch (Dali::DaliException e) {
74700       {
74701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74702       };
74703     } catch (...) {
74704       {
74705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74706       };
74707     }
74708   }
74709
74710 }
74711
74712
74713 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
74714   int jresult ;
74715   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74716   Dali::Toolkit::ControlOrientation::Type result;
74717
74718   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74719   {
74720     try {
74721       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
74722     } catch (std::out_of_range& e) {
74723       {
74724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74725       };
74726     } catch (std::exception& e) {
74727       {
74728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74729       };
74730     } catch (Dali::DaliException e) {
74731       {
74732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74733       };
74734     } catch (...) {
74735       {
74736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74737       };
74738     }
74739   }
74740
74741   jresult = (int)result;
74742   return jresult;
74743 }
74744
74745
74746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
74747   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74748   Dali::Property::Map *arg2 = 0 ;
74749
74750   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74751   arg2 = (Dali::Property::Map *)jarg2;
74752   if (!arg2) {
74753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
74754     return ;
74755   }
74756   {
74757     try {
74758       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
74759     } catch (std::out_of_range& e) {
74760       {
74761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74762       };
74763     } catch (std::exception& e) {
74764       {
74765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74766       };
74767     } catch (Dali::DaliException e) {
74768       {
74769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74770       };
74771     } catch (...) {
74772       {
74773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74774       };
74775     }
74776   }
74777
74778 }
74779
74780
74781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
74782   void * jresult ;
74783   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74784   Dali::Property::Map result;
74785
74786   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74787   {
74788     try {
74789       result = (arg1)->GetLayoutProperties();
74790     } catch (std::out_of_range& e) {
74791       {
74792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74793       };
74794     } catch (std::exception& e) {
74795       {
74796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74797       };
74798     } catch (Dali::DaliException e) {
74799       {
74800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74801       };
74802     } catch (...) {
74803       {
74804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74805       };
74806     }
74807   }
74808
74809   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
74810   return jresult;
74811 }
74812
74813
74814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
74815   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74816   unsigned int arg2 ;
74817   Dali::Vector3 *arg3 = 0 ;
74818   Dali::Vector3 *arg4 = 0 ;
74819
74820   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74821   arg2 = (unsigned int)jarg2;
74822   arg3 = (Dali::Vector3 *)jarg3;
74823   if (!arg3) {
74824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74825     return ;
74826   }
74827   arg4 = (Dali::Vector3 *)jarg4;
74828   if (!arg4) {
74829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
74830     return ;
74831   }
74832   {
74833     try {
74834       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
74835     } catch (std::out_of_range& e) {
74836       {
74837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74838       };
74839     } catch (std::exception& e) {
74840       {
74841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74842       };
74843     } catch (Dali::DaliException e) {
74844       {
74845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74846       };
74847     } catch (...) {
74848       {
74849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74850       };
74851     }
74852   }
74853
74854 }
74855
74856
74857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
74858   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74859   Dali::Vector3 *arg2 = 0 ;
74860
74861   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74862   arg2 = (Dali::Vector3 *)jarg2;
74863   if (!arg2) {
74864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74865     return ;
74866   }
74867   {
74868     try {
74869       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
74870     } catch (std::out_of_range& e) {
74871       {
74872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74873       };
74874     } catch (std::exception& e) {
74875       {
74876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74877       };
74878     } catch (Dali::DaliException e) {
74879       {
74880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74881       };
74882     } catch (...) {
74883       {
74884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74885       };
74886     }
74887   }
74888
74889 }
74890
74891
74892 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
74893   float jresult ;
74894   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74895   unsigned int arg2 ;
74896   Dali::Vector3 arg3 ;
74897   Dali::Vector3 *argp3 ;
74898   float result;
74899
74900   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74901   arg2 = (unsigned int)jarg2;
74902   argp3 = (Dali::Vector3 *)jarg3;
74903   if (!argp3) {
74904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
74905     return 0;
74906   }
74907   arg3 = *argp3;
74908   {
74909     try {
74910       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
74911     } catch (std::out_of_range& e) {
74912       {
74913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74914       };
74915     } catch (std::exception& e) {
74916       {
74917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74918       };
74919     } catch (Dali::DaliException e) {
74920       {
74921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74922       };
74923     } catch (...) {
74924       {
74925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74926       };
74927     }
74928   }
74929
74930   jresult = result;
74931   return jresult;
74932 }
74933
74934
74935 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
74936   float jresult ;
74937   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74938   float arg2 ;
74939   float result;
74940
74941   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74942   arg2 = (float)jarg2;
74943   {
74944     try {
74945       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
74946     } catch (std::out_of_range& e) {
74947       {
74948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74949       };
74950     } catch (std::exception& e) {
74951       {
74952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74953       };
74954     } catch (Dali::DaliException e) {
74955       {
74956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74957       };
74958     } catch (...) {
74959       {
74960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74961       };
74962     }
74963   }
74964
74965   jresult = result;
74966   return jresult;
74967 }
74968
74969
74970 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
74971   float jresult ;
74972   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74973   unsigned int arg2 ;
74974   float result;
74975
74976   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74977   arg2 = (unsigned int)jarg2;
74978   {
74979     try {
74980       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
74981     } catch (std::out_of_range& e) {
74982       {
74983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74984       };
74985     } catch (std::exception& e) {
74986       {
74987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74988       };
74989     } catch (Dali::DaliException e) {
74990       {
74991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74992       };
74993     } catch (...) {
74994       {
74995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74996       };
74997     }
74998   }
74999
75000   jresult = result;
75001   return jresult;
75002 }
75003
75004
75005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
75006   void * jresult ;
75007   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75008   float arg2 ;
75009   Dali::Vector3 arg3 ;
75010   Dali::Vector3 *argp3 ;
75011   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
75012
75013   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75014   arg2 = (float)jarg2;
75015   argp3 = (Dali::Vector3 *)jarg3;
75016   if (!argp3) {
75017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75018     return 0;
75019   }
75020   arg3 = *argp3;
75021   {
75022     try {
75023       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
75024     } catch (std::out_of_range& e) {
75025       {
75026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75027       };
75028     } catch (std::exception& e) {
75029       {
75030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75031       };
75032     } catch (Dali::DaliException e) {
75033       {
75034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75035       };
75036     } catch (...) {
75037       {
75038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75039       };
75040     }
75041   }
75042
75043   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
75044   return jresult;
75045 }
75046
75047
75048 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75049   float jresult ;
75050   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75051   int arg2 ;
75052   float arg3 ;
75053   Dali::Vector3 *arg4 = 0 ;
75054   float result;
75055
75056   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75057   arg2 = (int)jarg2;
75058   arg3 = (float)jarg3;
75059   arg4 = (Dali::Vector3 *)jarg4;
75060   if (!arg4) {
75061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75062     return 0;
75063   }
75064   {
75065     try {
75066       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75067     } catch (std::out_of_range& e) {
75068       {
75069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75070       };
75071     } catch (std::exception& e) {
75072       {
75073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75074       };
75075     } catch (Dali::DaliException e) {
75076       {
75077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75078       };
75079     } catch (...) {
75080       {
75081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75082       };
75083     }
75084   }
75085
75086   jresult = result;
75087   return jresult;
75088 }
75089
75090
75091 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
75092   unsigned int jresult ;
75093   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75094   Dali::Vector3 arg2 ;
75095   Dali::Vector3 *argp2 ;
75096   unsigned int result;
75097
75098   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75099   argp2 = (Dali::Vector3 *)jarg2;
75100   if (!argp2) {
75101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75102     return 0;
75103   }
75104   arg2 = *argp2;
75105   {
75106     try {
75107       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
75108     } catch (std::out_of_range& e) {
75109       {
75110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75111       };
75112     } catch (std::exception& e) {
75113       {
75114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75115       };
75116     } catch (Dali::DaliException e) {
75117       {
75118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75119       };
75120     } catch (...) {
75121       {
75122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75123       };
75124     }
75125   }
75126
75127   jresult = result;
75128   return jresult;
75129 }
75130
75131
75132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
75133   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75134   unsigned int arg2 ;
75135   Dali::Vector3 *arg3 = 0 ;
75136   Dali::Vector3 *arg4 = 0 ;
75137
75138   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75139   arg2 = (unsigned int)jarg2;
75140   arg3 = (Dali::Vector3 *)jarg3;
75141   if (!arg3) {
75142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75143     return ;
75144   }
75145   arg4 = (Dali::Vector3 *)jarg4;
75146   if (!arg4) {
75147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
75148     return ;
75149   }
75150   {
75151     try {
75152       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
75153     } catch (std::out_of_range& e) {
75154       {
75155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75156       };
75157     } catch (std::exception& e) {
75158       {
75159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75160       };
75161     } catch (Dali::DaliException e) {
75162       {
75163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75164       };
75165     } catch (...) {
75166       {
75167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75168       };
75169     }
75170   }
75171
75172 }
75173
75174
75175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
75176   void * jresult ;
75177   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75178   Dali::Degree result;
75179
75180   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75181   {
75182     try {
75183       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
75184     } catch (std::out_of_range& e) {
75185       {
75186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75187       };
75188     } catch (std::exception& e) {
75189       {
75190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75191       };
75192     } catch (Dali::DaliException e) {
75193       {
75194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75195       };
75196     } catch (...) {
75197       {
75198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75199       };
75200     }
75201   }
75202
75203   jresult = new Dali::Degree((const Dali::Degree &)result);
75204   return jresult;
75205 }
75206
75207
75208 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
75209   float jresult ;
75210   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75211   float result;
75212
75213   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75214   {
75215     try {
75216       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
75217     } catch (std::out_of_range& e) {
75218       {
75219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75220       };
75221     } catch (std::exception& e) {
75222       {
75223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75224       };
75225     } catch (Dali::DaliException e) {
75226       {
75227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75228       };
75229     } catch (...) {
75230       {
75231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75232       };
75233     }
75234   }
75235
75236   jresult = result;
75237   return jresult;
75238 }
75239
75240
75241 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
75242   float jresult ;
75243   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75244   float result;
75245
75246   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75247   {
75248     try {
75249       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
75250     } catch (std::out_of_range& e) {
75251       {
75252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75253       };
75254     } catch (std::exception& e) {
75255       {
75256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75257       };
75258     } catch (Dali::DaliException e) {
75259       {
75260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75261       };
75262     } catch (...) {
75263       {
75264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75265       };
75266     }
75267   }
75268
75269   jresult = result;
75270   return jresult;
75271 }
75272
75273
75274 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
75275   float jresult ;
75276   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75277   float result;
75278
75279   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75280   {
75281     try {
75282       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
75283     } catch (std::out_of_range& e) {
75284       {
75285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75286       };
75287     } catch (std::exception& e) {
75288       {
75289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75290       };
75291     } catch (Dali::DaliException e) {
75292       {
75293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75294       };
75295     } catch (...) {
75296       {
75297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75298       };
75299     }
75300   }
75301
75302   jresult = result;
75303   return jresult;
75304 }
75305
75306
75307 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
75308   int jresult ;
75309   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75310   int arg2 ;
75311   int arg3 ;
75312   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
75313   bool arg5 ;
75314   int result;
75315
75316   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75317   arg2 = (int)jarg2;
75318   arg3 = (int)jarg3;
75319   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
75320   arg5 = jarg5 ? true : false;
75321   {
75322     try {
75323       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
75324     } catch (std::out_of_range& e) {
75325       {
75326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75327       };
75328     } catch (std::exception& e) {
75329       {
75330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75331       };
75332     } catch (Dali::DaliException e) {
75333       {
75334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75335       };
75336     } catch (...) {
75337       {
75338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75339       };
75340     }
75341   }
75342
75343   jresult = result;
75344   return jresult;
75345 }
75346
75347
75348 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
75349   float jresult ;
75350   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75351   float result;
75352
75353   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75354   {
75355     try {
75356       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
75357     } catch (std::out_of_range& e) {
75358       {
75359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75360       };
75361     } catch (std::exception& e) {
75362       {
75363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75364       };
75365     } catch (Dali::DaliException e) {
75366       {
75367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75368       };
75369     } catch (...) {
75370       {
75371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75372       };
75373     }
75374   }
75375
75376   jresult = result;
75377   return jresult;
75378 }
75379
75380
75381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
75382   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75383   Dali::Actor *arg2 = 0 ;
75384   int arg3 ;
75385   Dali::Vector3 *arg4 = 0 ;
75386   Dali::Actor *arg5 = 0 ;
75387
75388   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75389   arg2 = (Dali::Actor *)jarg2;
75390   if (!arg2) {
75391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75392     return ;
75393   }
75394   arg3 = (int)jarg3;
75395   arg4 = (Dali::Vector3 *)jarg4;
75396   if (!arg4) {
75397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75398     return ;
75399   }
75400   arg5 = (Dali::Actor *)jarg5;
75401   if (!arg5) {
75402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
75403     return ;
75404   }
75405   {
75406     try {
75407       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
75408     } catch (std::out_of_range& e) {
75409       {
75410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75411       };
75412     } catch (std::exception& e) {
75413       {
75414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75415       };
75416     } catch (Dali::DaliException e) {
75417       {
75418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75419       };
75420     } catch (...) {
75421       {
75422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75423       };
75424     }
75425   }
75426
75427 }
75428
75429
75430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75431   void * jresult ;
75432   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75433   int arg2 ;
75434   float arg3 ;
75435   Dali::Vector3 *arg4 = 0 ;
75436   Dali::Vector3 result;
75437
75438   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75439   arg2 = (int)jarg2;
75440   arg3 = (float)jarg3;
75441   arg4 = (Dali::Vector3 *)jarg4;
75442   if (!arg4) {
75443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75444     return 0;
75445   }
75446   {
75447     try {
75448       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75449     } catch (std::out_of_range& e) {
75450       {
75451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75452       };
75453     } catch (std::exception& e) {
75454       {
75455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75456       };
75457     } catch (Dali::DaliException e) {
75458       {
75459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75460       };
75461     } catch (...) {
75462       {
75463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75464       };
75465     }
75466   }
75467
75468   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
75469   return jresult;
75470 }
75471
75472
75473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
75474   void * jresult ;
75475   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
75476   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75477
75478   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
75479   {
75480     try {
75481       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
75482     } catch (std::out_of_range& e) {
75483       {
75484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75485       };
75486     } catch (std::exception& e) {
75487       {
75488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75489       };
75490     } catch (Dali::DaliException e) {
75491       {
75492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75493       };
75494     } catch (...) {
75495       {
75496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75497       };
75498     }
75499   }
75500
75501   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75502   return jresult;
75503 }
75504
75505
75506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
75507   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75508
75509   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75510   {
75511     try {
75512       delete arg1;
75513     } catch (std::out_of_range& e) {
75514       {
75515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75516       };
75517     } catch (std::exception& e) {
75518       {
75519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75520       };
75521     } catch (Dali::DaliException e) {
75522       {
75523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75524       };
75525     } catch (...) {
75526       {
75527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75528       };
75529     }
75530   }
75531
75532 }
75533
75534
75535 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
75536   unsigned int jresult ;
75537   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75538   unsigned int result;
75539
75540   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75541   {
75542     try {
75543       result = (unsigned int)(arg1)->GetNumberOfItems();
75544     } catch (std::out_of_range& e) {
75545       {
75546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75547       };
75548     } catch (std::exception& e) {
75549       {
75550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75551       };
75552     } catch (Dali::DaliException e) {
75553       {
75554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75555       };
75556     } catch (...) {
75557       {
75558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75559       };
75560     }
75561   }
75562
75563   jresult = result;
75564   return jresult;
75565 }
75566
75567
75568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
75569   void * jresult ;
75570   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75571   unsigned int arg2 ;
75572   Dali::Actor result;
75573
75574   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75575   arg2 = (unsigned int)jarg2;
75576   {
75577     try {
75578       result = (arg1)->NewItem(arg2);
75579     } catch (std::out_of_range& e) {
75580       {
75581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75582       };
75583     } catch (std::exception& e) {
75584       {
75585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75586       };
75587     } catch (Dali::DaliException e) {
75588       {
75589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75590       };
75591     } catch (...) {
75592       {
75593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75594       };
75595     }
75596   }
75597
75598   jresult = new Dali::Actor((const Dali::Actor &)result);
75599   return jresult;
75600 }
75601
75602
75603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
75604   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75605   unsigned int arg2 ;
75606   Dali::Actor arg3 ;
75607   Dali::Actor *argp3 ;
75608
75609   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75610   arg2 = (unsigned int)jarg2;
75611   argp3 = (Dali::Actor *)jarg3;
75612   if (!argp3) {
75613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75614     return ;
75615   }
75616   arg3 = *argp3;
75617   {
75618     try {
75619       (arg1)->ItemReleased(arg2,arg3);
75620     } catch (std::out_of_range& e) {
75621       {
75622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75623       };
75624     } catch (std::exception& e) {
75625       {
75626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75627       };
75628     } catch (Dali::DaliException e) {
75629       {
75630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75631       };
75632     } catch (...) {
75633       {
75634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75635       };
75636     }
75637   }
75638
75639 }
75640
75641
75642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
75643   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75644   unsigned int arg2 ;
75645   Dali::Actor arg3 ;
75646   Dali::Actor *argp3 ;
75647
75648   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75649   arg2 = (unsigned int)jarg2;
75650   argp3 = (Dali::Actor *)jarg3;
75651   if (!argp3) {
75652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75653     return ;
75654   }
75655   arg3 = *argp3;
75656   {
75657     try {
75658       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
75659     } catch (std::out_of_range& e) {
75660       {
75661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75662       };
75663     } catch (std::exception& e) {
75664       {
75665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75666       };
75667     } catch (Dali::DaliException e) {
75668       {
75669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75670       };
75671     } catch (...) {
75672       {
75673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75674       };
75675     }
75676   }
75677
75678 }
75679
75680
75681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
75682   void * jresult ;
75683   Dali::Toolkit::ItemFactory *result = 0 ;
75684
75685   {
75686     try {
75687       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
75688     } catch (std::out_of_range& e) {
75689       {
75690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75691       };
75692     } catch (std::exception& e) {
75693       {
75694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75695       };
75696     } catch (Dali::DaliException e) {
75697       {
75698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75699       };
75700     } catch (...) {
75701       {
75702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75703       };
75704     }
75705   }
75706
75707   jresult = (void *)result;
75708   return jresult;
75709 }
75710
75711
75712 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) {
75713   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
75714   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
75715   if (director) {
75716     director->swig_connect_director(callback0, callback1, callback2);
75717   }
75718 }
75719
75720
75721 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
75722   int jresult ;
75723   int result;
75724
75725   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
75726   jresult = (int)result;
75727   return jresult;
75728 }
75729
75730
75731 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
75732   int jresult ;
75733   int result;
75734
75735   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
75736   jresult = (int)result;
75737   return jresult;
75738 }
75739
75740
75741 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
75742   int jresult ;
75743   int result;
75744
75745   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
75746   jresult = (int)result;
75747   return jresult;
75748 }
75749
75750
75751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
75752   int jresult ;
75753   int result;
75754
75755   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
75756   jresult = (int)result;
75757   return jresult;
75758 }
75759
75760
75761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
75762   int jresult ;
75763   int result;
75764
75765   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
75766   jresult = (int)result;
75767   return jresult;
75768 }
75769
75770
75771 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
75772   int jresult ;
75773   int result;
75774
75775   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
75776   jresult = (int)result;
75777   return jresult;
75778 }
75779
75780
75781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
75782   int jresult ;
75783   int result;
75784
75785   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
75786   jresult = (int)result;
75787   return jresult;
75788 }
75789
75790
75791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
75792   int jresult ;
75793   int result;
75794
75795   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
75796   jresult = (int)result;
75797   return jresult;
75798 }
75799
75800
75801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
75802   int jresult ;
75803   int result;
75804
75805   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
75806   jresult = (int)result;
75807   return jresult;
75808 }
75809
75810
75811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
75812   int jresult ;
75813   int result;
75814
75815   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
75816   jresult = (int)result;
75817   return jresult;
75818 }
75819
75820
75821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
75822   int jresult ;
75823   int result;
75824
75825   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
75826   jresult = (int)result;
75827   return jresult;
75828 }
75829
75830
75831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
75832   void * jresult ;
75833   Dali::Toolkit::ItemView::Property *result = 0 ;
75834
75835   {
75836     try {
75837       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
75838     } catch (std::out_of_range& e) {
75839       {
75840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75841       };
75842     } catch (std::exception& e) {
75843       {
75844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75845       };
75846     } catch (Dali::DaliException e) {
75847       {
75848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75849       };
75850     } catch (...) {
75851       {
75852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75853       };
75854     }
75855   }
75856
75857   jresult = (void *)result;
75858   return jresult;
75859 }
75860
75861
75862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
75863   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
75864
75865   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
75866   {
75867     try {
75868       delete arg1;
75869     } catch (std::out_of_range& e) {
75870       {
75871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75872       };
75873     } catch (std::exception& e) {
75874       {
75875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75876       };
75877     } catch (Dali::DaliException e) {
75878       {
75879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75880       };
75881     } catch (...) {
75882       {
75883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75884       };
75885     }
75886   }
75887
75888 }
75889
75890
75891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
75892   void * jresult ;
75893   Dali::Toolkit::ItemView *result = 0 ;
75894
75895   {
75896     try {
75897       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
75898     } catch (std::out_of_range& e) {
75899       {
75900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75901       };
75902     } catch (std::exception& e) {
75903       {
75904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75905       };
75906     } catch (Dali::DaliException e) {
75907       {
75908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75909       };
75910     } catch (...) {
75911       {
75912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75913       };
75914     }
75915   }
75916
75917   jresult = (void *)result;
75918   return jresult;
75919 }
75920
75921
75922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
75923   void * jresult ;
75924   Dali::Toolkit::ItemView *arg1 = 0 ;
75925   Dali::Toolkit::ItemView *result = 0 ;
75926
75927   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75928   if (!arg1) {
75929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
75930     return 0;
75931   }
75932   {
75933     try {
75934       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
75935     } catch (std::out_of_range& e) {
75936       {
75937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75938       };
75939     } catch (std::exception& e) {
75940       {
75941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75942       };
75943     } catch (Dali::DaliException e) {
75944       {
75945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75946       };
75947     } catch (...) {
75948       {
75949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75950       };
75951     }
75952   }
75953
75954   jresult = (void *)result;
75955   return jresult;
75956 }
75957
75958
75959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
75960   void * jresult ;
75961   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75962   Dali::Toolkit::ItemView *arg2 = 0 ;
75963   Dali::Toolkit::ItemView *result = 0 ;
75964
75965   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75966   arg2 = (Dali::Toolkit::ItemView *)jarg2;
75967   if (!arg2) {
75968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
75969     return 0;
75970   }
75971   {
75972     try {
75973       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
75974     } catch (std::out_of_range& e) {
75975       {
75976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75977       };
75978     } catch (std::exception& e) {
75979       {
75980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75981       };
75982     } catch (Dali::DaliException e) {
75983       {
75984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75985       };
75986     } catch (...) {
75987       {
75988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75989       };
75990     }
75991   }
75992
75993   jresult = (void *)result;
75994   return jresult;
75995 }
75996
75997
75998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
75999   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76000
76001   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76002   {
76003     try {
76004       delete arg1;
76005     } catch (std::out_of_range& e) {
76006       {
76007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76008       };
76009     } catch (std::exception& e) {
76010       {
76011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76012       };
76013     } catch (Dali::DaliException e) {
76014       {
76015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76016       };
76017     } catch (...) {
76018       {
76019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76020       };
76021     }
76022   }
76023
76024 }
76025
76026
76027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
76028   void * jresult ;
76029   Dali::Toolkit::ItemFactory *arg1 = 0 ;
76030   Dali::Toolkit::ItemView result;
76031
76032   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76033   if (!arg1) {
76034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
76035     return 0;
76036   }
76037   {
76038     try {
76039       result = Dali::Toolkit::ItemView::New(*arg1);
76040     } catch (std::out_of_range& e) {
76041       {
76042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76043       };
76044     } catch (std::exception& e) {
76045       {
76046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76047       };
76048     } catch (Dali::DaliException e) {
76049       {
76050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76051       };
76052     } catch (...) {
76053       {
76054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76055       };
76056     }
76057   }
76058
76059   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
76060   return jresult;
76061 }
76062
76063
76064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
76065   void * jresult ;
76066   Dali::BaseHandle arg1 ;
76067   Dali::BaseHandle *argp1 ;
76068   Dali::Toolkit::ItemView result;
76069
76070   argp1 = (Dali::BaseHandle *)jarg1;
76071   if (!argp1) {
76072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76073     return 0;
76074   }
76075   arg1 = *argp1;
76076   {
76077     try {
76078       result = Dali::Toolkit::ItemView::DownCast(arg1);
76079     } catch (std::out_of_range& e) {
76080       {
76081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76082       };
76083     } catch (std::exception& e) {
76084       {
76085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76086       };
76087     } catch (Dali::DaliException e) {
76088       {
76089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76090       };
76091     } catch (...) {
76092       {
76093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76094       };
76095     }
76096   }
76097
76098   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
76099   return jresult;
76100 }
76101
76102
76103 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
76104   unsigned int jresult ;
76105   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76106   unsigned int result;
76107
76108   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76109   {
76110     try {
76111       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
76112     } catch (std::out_of_range& e) {
76113       {
76114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76115       };
76116     } catch (std::exception& e) {
76117       {
76118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76119       };
76120     } catch (Dali::DaliException e) {
76121       {
76122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76123       };
76124     } catch (...) {
76125       {
76126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76127       };
76128     }
76129   }
76130
76131   jresult = result;
76132   return jresult;
76133 }
76134
76135
76136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
76137   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76138   Dali::Toolkit::ItemLayout *arg2 = 0 ;
76139
76140   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76141   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
76142   if (!arg2) {
76143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
76144     return ;
76145   }
76146   {
76147     try {
76148       (arg1)->AddLayout(*arg2);
76149     } catch (std::out_of_range& e) {
76150       {
76151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76152       };
76153     } catch (std::exception& e) {
76154       {
76155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76156       };
76157     } catch (Dali::DaliException e) {
76158       {
76159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76160       };
76161     } catch (...) {
76162       {
76163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76164       };
76165     }
76166   }
76167
76168 }
76169
76170
76171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
76172   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76173   unsigned int arg2 ;
76174
76175   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76176   arg2 = (unsigned int)jarg2;
76177   {
76178     try {
76179       (arg1)->RemoveLayout(arg2);
76180     } catch (std::out_of_range& e) {
76181       {
76182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76183       };
76184     } catch (std::exception& e) {
76185       {
76186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76187       };
76188     } catch (Dali::DaliException e) {
76189       {
76190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76191       };
76192     } catch (...) {
76193       {
76194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76195       };
76196     }
76197   }
76198
76199 }
76200
76201
76202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
76203   void * jresult ;
76204   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76205   unsigned int arg2 ;
76206   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76207
76208   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76209   arg2 = (unsigned int)jarg2;
76210   {
76211     try {
76212       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
76213     } catch (std::out_of_range& e) {
76214       {
76215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76216       };
76217     } catch (std::exception& e) {
76218       {
76219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76220       };
76221     } catch (Dali::DaliException e) {
76222       {
76223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76224       };
76225     } catch (...) {
76226       {
76227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76228       };
76229     }
76230   }
76231
76232   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76233   return jresult;
76234 }
76235
76236
76237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
76238   void * jresult ;
76239   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76240   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76241
76242   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76243   {
76244     try {
76245       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
76246     } catch (std::out_of_range& e) {
76247       {
76248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76249       };
76250     } catch (std::exception& e) {
76251       {
76252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76253       };
76254     } catch (Dali::DaliException e) {
76255       {
76256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76257       };
76258     } catch (...) {
76259       {
76260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76261       };
76262     }
76263   }
76264
76265   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76266   return jresult;
76267 }
76268
76269
76270 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
76271   float jresult ;
76272   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76273   Dali::Toolkit::ItemId arg2 ;
76274   float result;
76275
76276   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76277   arg2 = (Dali::Toolkit::ItemId)jarg2;
76278   {
76279     try {
76280       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
76281     } catch (std::out_of_range& e) {
76282       {
76283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76284       };
76285     } catch (std::exception& e) {
76286       {
76287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76288       };
76289     } catch (Dali::DaliException e) {
76290       {
76291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76292       };
76293     } catch (...) {
76294       {
76295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76296       };
76297     }
76298   }
76299
76300   jresult = result;
76301   return jresult;
76302 }
76303
76304
76305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
76306   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76307   unsigned int arg2 ;
76308   Dali::Vector3 arg3 ;
76309   float arg4 ;
76310   Dali::Vector3 *argp3 ;
76311
76312   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76313   arg2 = (unsigned int)jarg2;
76314   argp3 = (Dali::Vector3 *)jarg3;
76315   if (!argp3) {
76316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
76317     return ;
76318   }
76319   arg3 = *argp3;
76320   arg4 = (float)jarg4;
76321   {
76322     try {
76323       (arg1)->ActivateLayout(arg2,arg3,arg4);
76324     } catch (std::out_of_range& e) {
76325       {
76326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76327       };
76328     } catch (std::exception& e) {
76329       {
76330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76331       };
76332     } catch (Dali::DaliException e) {
76333       {
76334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76335       };
76336     } catch (...) {
76337       {
76338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76339       };
76340     }
76341   }
76342
76343 }
76344
76345
76346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
76347   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76348
76349   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76350   {
76351     try {
76352       (arg1)->DeactivateCurrentLayout();
76353     } catch (std::out_of_range& e) {
76354       {
76355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76356       };
76357     } catch (std::exception& e) {
76358       {
76359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76360       };
76361     } catch (Dali::DaliException e) {
76362       {
76363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76364       };
76365     } catch (...) {
76366       {
76367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76368       };
76369     }
76370   }
76371
76372 }
76373
76374
76375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
76376   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76377   float arg2 ;
76378
76379   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76380   arg2 = (float)jarg2;
76381   {
76382     try {
76383       (arg1)->SetMinimumSwipeSpeed(arg2);
76384     } catch (std::out_of_range& e) {
76385       {
76386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76387       };
76388     } catch (std::exception& e) {
76389       {
76390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76391       };
76392     } catch (Dali::DaliException e) {
76393       {
76394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76395       };
76396     } catch (...) {
76397       {
76398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76399       };
76400     }
76401   }
76402
76403 }
76404
76405
76406 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
76407   float jresult ;
76408   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76409   float result;
76410
76411   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76412   {
76413     try {
76414       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
76415     } catch (std::out_of_range& e) {
76416       {
76417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76418       };
76419     } catch (std::exception& e) {
76420       {
76421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76422       };
76423     } catch (Dali::DaliException e) {
76424       {
76425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76426       };
76427     } catch (...) {
76428       {
76429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76430       };
76431     }
76432   }
76433
76434   jresult = result;
76435   return jresult;
76436 }
76437
76438
76439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
76440   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76441   float arg2 ;
76442
76443   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76444   arg2 = (float)jarg2;
76445   {
76446     try {
76447       (arg1)->SetMinimumSwipeDistance(arg2);
76448     } catch (std::out_of_range& e) {
76449       {
76450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76451       };
76452     } catch (std::exception& e) {
76453       {
76454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76455       };
76456     } catch (Dali::DaliException e) {
76457       {
76458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76459       };
76460     } catch (...) {
76461       {
76462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76463       };
76464     }
76465   }
76466
76467 }
76468
76469
76470 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
76471   float jresult ;
76472   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76473   float result;
76474
76475   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76476   {
76477     try {
76478       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
76479     } catch (std::out_of_range& e) {
76480       {
76481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76482       };
76483     } catch (std::exception& e) {
76484       {
76485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76486       };
76487     } catch (Dali::DaliException e) {
76488       {
76489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76490       };
76491     } catch (...) {
76492       {
76493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76494       };
76495     }
76496   }
76497
76498   jresult = result;
76499   return jresult;
76500 }
76501
76502
76503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
76504   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76505   float arg2 ;
76506
76507   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76508   arg2 = (float)jarg2;
76509   {
76510     try {
76511       (arg1)->SetWheelScrollDistanceStep(arg2);
76512     } catch (std::out_of_range& e) {
76513       {
76514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76515       };
76516     } catch (std::exception& e) {
76517       {
76518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76519       };
76520     } catch (Dali::DaliException e) {
76521       {
76522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76523       };
76524     } catch (...) {
76525       {
76526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76527       };
76528     }
76529   }
76530
76531 }
76532
76533
76534 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
76535   float jresult ;
76536   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76537   float result;
76538
76539   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76540   {
76541     try {
76542       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
76543     } catch (std::out_of_range& e) {
76544       {
76545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76546       };
76547     } catch (std::exception& e) {
76548       {
76549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76550       };
76551     } catch (Dali::DaliException e) {
76552       {
76553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76554       };
76555     } catch (...) {
76556       {
76557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76558       };
76559     }
76560   }
76561
76562   jresult = result;
76563   return jresult;
76564 }
76565
76566
76567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
76568   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76569   bool arg2 ;
76570
76571   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76572   arg2 = jarg2 ? true : false;
76573   {
76574     try {
76575       (arg1)->SetAnchoring(arg2);
76576     } catch (std::out_of_range& e) {
76577       {
76578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76579       };
76580     } catch (std::exception& e) {
76581       {
76582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76583       };
76584     } catch (Dali::DaliException e) {
76585       {
76586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76587       };
76588     } catch (...) {
76589       {
76590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76591       };
76592     }
76593   }
76594
76595 }
76596
76597 //// ========================= end of part 3 =============================
76598
76599 //// ========================== start part 4 ===============================
76600
76601
76602 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
76603   unsigned int jresult ;
76604   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76605   bool result;
76606
76607   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76608   {
76609     try {
76610       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
76611     } catch (std::out_of_range& e) {
76612       {
76613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76614       };
76615     } catch (std::exception& e) {
76616       {
76617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76618       };
76619     } catch (Dali::DaliException e) {
76620       {
76621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76622       };
76623     } catch (...) {
76624       {
76625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76626       };
76627     }
76628   }
76629
76630   jresult = result;
76631   return jresult;
76632 }
76633
76634
76635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
76636   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76637   float arg2 ;
76638
76639   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76640   arg2 = (float)jarg2;
76641   {
76642     try {
76643       (arg1)->SetAnchoringDuration(arg2);
76644     } catch (std::out_of_range& e) {
76645       {
76646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76647       };
76648     } catch (std::exception& e) {
76649       {
76650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76651       };
76652     } catch (Dali::DaliException e) {
76653       {
76654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76655       };
76656     } catch (...) {
76657       {
76658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76659       };
76660     }
76661   }
76662
76663 }
76664
76665
76666 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
76667   float jresult ;
76668   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76669   float result;
76670
76671   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76672   {
76673     try {
76674       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
76675     } catch (std::out_of_range& e) {
76676       {
76677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76678       };
76679     } catch (std::exception& e) {
76680       {
76681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76682       };
76683     } catch (Dali::DaliException e) {
76684       {
76685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76686       };
76687     } catch (...) {
76688       {
76689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76690       };
76691     }
76692   }
76693
76694   jresult = result;
76695   return jresult;
76696 }
76697
76698
76699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
76700   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76701   Dali::Toolkit::ItemId arg2 ;
76702   float arg3 ;
76703
76704   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76705   arg2 = (Dali::Toolkit::ItemId)jarg2;
76706   arg3 = (float)jarg3;
76707   {
76708     try {
76709       (arg1)->ScrollToItem(arg2,arg3);
76710     } catch (std::out_of_range& e) {
76711       {
76712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76713       };
76714     } catch (std::exception& e) {
76715       {
76716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76717       };
76718     } catch (Dali::DaliException e) {
76719       {
76720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76721       };
76722     } catch (...) {
76723       {
76724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76725       };
76726     }
76727   }
76728
76729 }
76730
76731
76732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
76733   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76734   float arg2 ;
76735
76736   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76737   arg2 = (float)jarg2;
76738   {
76739     try {
76740       (arg1)->SetRefreshInterval(arg2);
76741     } catch (std::out_of_range& e) {
76742       {
76743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76744       };
76745     } catch (std::exception& e) {
76746       {
76747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76748       };
76749     } catch (Dali::DaliException e) {
76750       {
76751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76752       };
76753     } catch (...) {
76754       {
76755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76756       };
76757     }
76758   }
76759
76760 }
76761
76762
76763 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
76764   float jresult ;
76765   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76766   float result;
76767
76768   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76769   {
76770     try {
76771       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
76772     } catch (std::out_of_range& e) {
76773       {
76774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76775       };
76776     } catch (std::exception& e) {
76777       {
76778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76779       };
76780     } catch (Dali::DaliException e) {
76781       {
76782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76783       };
76784     } catch (...) {
76785       {
76786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76787       };
76788     }
76789   }
76790
76791   jresult = result;
76792   return jresult;
76793 }
76794
76795
76796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
76797   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76798
76799   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76800   {
76801     try {
76802       (arg1)->Refresh();
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_GetItem(void * jarg1, unsigned int jarg2) {
76826   void * jresult ;
76827   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76828   Dali::Toolkit::ItemId arg2 ;
76829   Dali::Actor result;
76830
76831   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76832   arg2 = (Dali::Toolkit::ItemId)jarg2;
76833   {
76834     try {
76835       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
76836     } catch (std::out_of_range& e) {
76837       {
76838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76839       };
76840     } catch (std::exception& e) {
76841       {
76842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76843       };
76844     } catch (Dali::DaliException e) {
76845       {
76846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76847       };
76848     } catch (...) {
76849       {
76850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76851       };
76852     }
76853   }
76854
76855   jresult = new Dali::Actor((const Dali::Actor &)result);
76856   return jresult;
76857 }
76858
76859
76860 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
76861   unsigned int jresult ;
76862   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76863   Dali::Actor arg2 ;
76864   Dali::Actor *argp2 ;
76865   Dali::Toolkit::ItemId result;
76866
76867   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76868   argp2 = (Dali::Actor *)jarg2;
76869   if (!argp2) {
76870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76871     return 0;
76872   }
76873   arg2 = *argp2;
76874   {
76875     try {
76876       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
76877     } catch (std::out_of_range& e) {
76878       {
76879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76880       };
76881     } catch (std::exception& e) {
76882       {
76883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76884       };
76885     } catch (Dali::DaliException e) {
76886       {
76887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76888       };
76889     } catch (...) {
76890       {
76891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76892       };
76893     }
76894   }
76895
76896   jresult = result;
76897   return jresult;
76898 }
76899
76900
76901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
76902   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76903   Dali::Toolkit::Item arg2 ;
76904   float arg3 ;
76905   Dali::Toolkit::Item *argp2 ;
76906
76907   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76908   argp2 = (Dali::Toolkit::Item *)jarg2;
76909   if (!argp2) {
76910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
76911     return ;
76912   }
76913   arg2 = *argp2;
76914   arg3 = (float)jarg3;
76915   {
76916     try {
76917       (arg1)->InsertItem(arg2,arg3);
76918     } catch (std::out_of_range& e) {
76919       {
76920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76921       };
76922     } catch (std::exception& e) {
76923       {
76924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76925       };
76926     } catch (Dali::DaliException e) {
76927       {
76928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76929       };
76930     } catch (...) {
76931       {
76932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76933       };
76934     }
76935   }
76936
76937 }
76938
76939
76940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
76941   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76942   Dali::Toolkit::ItemContainer *arg2 = 0 ;
76943   float arg3 ;
76944
76945   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76946   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
76947   if (!arg2) {
76948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
76949     return ;
76950   }
76951   arg3 = (float)jarg3;
76952   {
76953     try {
76954       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
76955     } catch (std::out_of_range& e) {
76956       {
76957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76958       };
76959     } catch (std::exception& e) {
76960       {
76961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76962       };
76963     } catch (Dali::DaliException e) {
76964       {
76965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76966       };
76967     } catch (...) {
76968       {
76969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76970       };
76971     }
76972   }
76973
76974 }
76975
76976
76977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
76978   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76979   Dali::Toolkit::ItemId arg2 ;
76980   float arg3 ;
76981
76982   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76983   arg2 = (Dali::Toolkit::ItemId)jarg2;
76984   arg3 = (float)jarg3;
76985   {
76986     try {
76987       (arg1)->RemoveItem(arg2,arg3);
76988     } catch (std::out_of_range& e) {
76989       {
76990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76991       };
76992     } catch (std::exception& e) {
76993       {
76994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76995       };
76996     } catch (Dali::DaliException e) {
76997       {
76998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76999       };
77000     } catch (...) {
77001       {
77002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77003       };
77004     }
77005   }
77006
77007 }
77008
77009
77010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
77011   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77012   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
77013   float arg3 ;
77014
77015   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77016   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
77017   if (!arg2) {
77018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
77019     return ;
77020   }
77021   arg3 = (float)jarg3;
77022   {
77023     try {
77024       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
77025     } catch (std::out_of_range& e) {
77026       {
77027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77028       };
77029     } catch (std::exception& e) {
77030       {
77031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77032       };
77033     } catch (Dali::DaliException e) {
77034       {
77035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77036       };
77037     } catch (...) {
77038       {
77039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77040       };
77041     }
77042   }
77043
77044 }
77045
77046
77047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
77048   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77049   Dali::Toolkit::Item arg2 ;
77050   float arg3 ;
77051   Dali::Toolkit::Item *argp2 ;
77052
77053   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77054   argp2 = (Dali::Toolkit::Item *)jarg2;
77055   if (!argp2) {
77056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
77057     return ;
77058   }
77059   arg2 = *argp2;
77060   arg3 = (float)jarg3;
77061   {
77062     try {
77063       (arg1)->ReplaceItem(arg2,arg3);
77064     } catch (std::out_of_range& e) {
77065       {
77066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77067       };
77068     } catch (std::exception& e) {
77069       {
77070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77071       };
77072     } catch (Dali::DaliException e) {
77073       {
77074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77075       };
77076     } catch (...) {
77077       {
77078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77079       };
77080     }
77081   }
77082
77083 }
77084
77085
77086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
77087   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77088   Dali::Toolkit::ItemContainer *arg2 = 0 ;
77089   float arg3 ;
77090
77091   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77092   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
77093   if (!arg2) {
77094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
77095     return ;
77096   }
77097   arg3 = (float)jarg3;
77098   {
77099     try {
77100       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
77101     } catch (std::out_of_range& e) {
77102       {
77103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77104       };
77105     } catch (std::exception& e) {
77106       {
77107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77108       };
77109     } catch (Dali::DaliException e) {
77110       {
77111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77112       };
77113     } catch (...) {
77114       {
77115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77116       };
77117     }
77118   }
77119
77120 }
77121
77122
77123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
77124   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77125   Dali::Vector3 *arg2 = 0 ;
77126
77127   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77128   arg2 = (Dali::Vector3 *)jarg2;
77129   if (!arg2) {
77130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77131     return ;
77132   }
77133   {
77134     try {
77135       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
77136     } catch (std::out_of_range& e) {
77137       {
77138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77139       };
77140     } catch (std::exception& e) {
77141       {
77142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77143       };
77144     } catch (Dali::DaliException e) {
77145       {
77146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77147       };
77148     } catch (...) {
77149       {
77150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77151       };
77152     }
77153   }
77154
77155 }
77156
77157
77158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
77159   void * jresult ;
77160   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77161   Dali::Vector3 result;
77162
77163   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77164   {
77165     try {
77166       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
77167     } catch (std::out_of_range& e) {
77168       {
77169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77170       };
77171     } catch (std::exception& e) {
77172       {
77173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77174       };
77175     } catch (Dali::DaliException e) {
77176       {
77177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77178       };
77179     } catch (...) {
77180       {
77181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77182       };
77183     }
77184   }
77185
77186   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77187   return jresult;
77188 }
77189
77190
77191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
77192   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77193   Dali::Vector3 *arg2 = 0 ;
77194
77195   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77196   arg2 = (Dali::Vector3 *)jarg2;
77197   if (!arg2) {
77198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77199     return ;
77200   }
77201   {
77202     try {
77203       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
77204     } catch (std::out_of_range& e) {
77205       {
77206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77207       };
77208     } catch (std::exception& e) {
77209       {
77210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77211       };
77212     } catch (Dali::DaliException e) {
77213       {
77214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77215       };
77216     } catch (...) {
77217       {
77218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77219       };
77220     }
77221   }
77222
77223 }
77224
77225
77226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
77227   void * jresult ;
77228   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77229   Dali::Vector3 result;
77230
77231   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77232   {
77233     try {
77234       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
77235     } catch (std::out_of_range& e) {
77236       {
77237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77238       };
77239     } catch (std::exception& e) {
77240       {
77241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77242       };
77243     } catch (Dali::DaliException e) {
77244       {
77245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77246       };
77247     } catch (...) {
77248       {
77249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77250       };
77251     }
77252   }
77253
77254   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77255   return jresult;
77256 }
77257
77258
77259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
77260   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77261   Dali::Toolkit::ItemRange *arg2 = 0 ;
77262
77263   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77264   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
77265   if (!arg2) {
77266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
77267     return ;
77268   }
77269   {
77270     try {
77271       (arg1)->GetItemsRange(*arg2);
77272     } catch (std::out_of_range& e) {
77273       {
77274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77275       };
77276     } catch (std::exception& e) {
77277       {
77278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77279       };
77280     } catch (Dali::DaliException e) {
77281       {
77282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77283       };
77284     } catch (...) {
77285       {
77286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77287       };
77288     }
77289   }
77290
77291 }
77292
77293
77294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
77295   void * jresult ;
77296   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77297   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
77298
77299   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77300   {
77301     try {
77302       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
77303     } catch (std::out_of_range& e) {
77304       {
77305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77306       };
77307     } catch (std::exception& e) {
77308       {
77309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77310       };
77311     } catch (Dali::DaliException e) {
77312       {
77313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77314       };
77315     } catch (...) {
77316       {
77317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77318       };
77319     }
77320   }
77321
77322   jresult = (void *)result;
77323   return jresult;
77324 }
77325
77326
77327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
77328   Dali::Vector3 *arg1 = 0 ;
77329   PropertyInputContainer *arg2 = 0 ;
77330
77331   arg1 = (Dali::Vector3 *)jarg1;
77332   if (!arg1) {
77333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77334     return ;
77335   }
77336   arg2 = (PropertyInputContainer *)jarg2;
77337   if (!arg2) {
77338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77339     return ;
77340   }
77341   {
77342     try {
77343       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77344     } catch (std::out_of_range& e) {
77345       {
77346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77347       };
77348     } catch (std::exception& e) {
77349       {
77350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77351       };
77352     } catch (Dali::DaliException e) {
77353       {
77354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77355       };
77356     } catch (...) {
77357       {
77358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77359       };
77360     }
77361   }
77362
77363 }
77364
77365
77366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
77367   Dali::Vector3 *arg1 = 0 ;
77368   PropertyInputContainer *arg2 = 0 ;
77369
77370   arg1 = (Dali::Vector3 *)jarg1;
77371   if (!arg1) {
77372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77373     return ;
77374   }
77375   arg2 = (PropertyInputContainer *)jarg2;
77376   if (!arg2) {
77377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77378     return ;
77379   }
77380   {
77381     try {
77382       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77383     } catch (std::out_of_range& e) {
77384       {
77385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77386       };
77387     } catch (std::exception& e) {
77388       {
77389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77390       };
77391     } catch (Dali::DaliException e) {
77392       {
77393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77394       };
77395     } catch (...) {
77396       {
77397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77398       };
77399     }
77400   }
77401
77402 }
77403
77404
77405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
77406   void * jresult ;
77407   Dali::Toolkit::ScrollViewEffect *result = 0 ;
77408
77409   {
77410     try {
77411       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
77412     } catch (std::out_of_range& e) {
77413       {
77414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77415       };
77416     } catch (std::exception& e) {
77417       {
77418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77419       };
77420     } catch (Dali::DaliException e) {
77421       {
77422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77423       };
77424     } catch (...) {
77425       {
77426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77427       };
77428     }
77429   }
77430
77431   jresult = (void *)result;
77432   return jresult;
77433 }
77434
77435
77436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
77437   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
77438
77439   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
77440   {
77441     try {
77442       delete arg1;
77443     } catch (std::out_of_range& e) {
77444       {
77445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77446       };
77447     } catch (std::exception& e) {
77448       {
77449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77450       };
77451     } catch (Dali::DaliException e) {
77452       {
77453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77454       };
77455     } catch (...) {
77456       {
77457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77458       };
77459     }
77460   }
77461
77462 }
77463
77464
77465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
77466   void * jresult ;
77467   Dali::Path arg1 ;
77468   Dali::Vector3 *arg2 = 0 ;
77469   Dali::Property::Index arg3 ;
77470   Dali::Vector3 *arg4 = 0 ;
77471   unsigned int arg5 ;
77472   Dali::Path *argp1 ;
77473   Dali::Toolkit::ScrollViewPagePathEffect result;
77474
77475   argp1 = (Dali::Path *)jarg1;
77476   if (!argp1) {
77477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
77478     return 0;
77479   }
77480   arg1 = *argp1;
77481   arg2 = (Dali::Vector3 *)jarg2;
77482   if (!arg2) {
77483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77484     return 0;
77485   }
77486   arg3 = (Dali::Property::Index)jarg3;
77487   arg4 = (Dali::Vector3 *)jarg4;
77488   if (!arg4) {
77489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77490     return 0;
77491   }
77492   arg5 = (unsigned int)jarg5;
77493   {
77494     try {
77495       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
77496     } catch (std::out_of_range& e) {
77497       {
77498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77499       };
77500     } catch (std::exception& e) {
77501       {
77502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77503       };
77504     } catch (Dali::DaliException e) {
77505       {
77506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77507       };
77508     } catch (...) {
77509       {
77510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77511       };
77512     }
77513   }
77514
77515   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77516   return jresult;
77517 }
77518
77519
77520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
77521   void * jresult ;
77522   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
77523
77524   {
77525     try {
77526       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
77527     } catch (std::out_of_range& e) {
77528       {
77529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77530       };
77531     } catch (std::exception& e) {
77532       {
77533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77534       };
77535     } catch (Dali::DaliException e) {
77536       {
77537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77538       };
77539     } catch (...) {
77540       {
77541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77542       };
77543     }
77544   }
77545
77546   jresult = (void *)result;
77547   return jresult;
77548 }
77549
77550
77551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
77552   void * jresult ;
77553   Dali::BaseHandle arg1 ;
77554   Dali::BaseHandle *argp1 ;
77555   Dali::Toolkit::ScrollViewPagePathEffect result;
77556
77557   argp1 = (Dali::BaseHandle *)jarg1;
77558   if (!argp1) {
77559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77560     return 0;
77561   }
77562   arg1 = *argp1;
77563   {
77564     try {
77565       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
77566     } catch (std::out_of_range& e) {
77567       {
77568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77569       };
77570     } catch (std::exception& e) {
77571       {
77572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77573       };
77574     } catch (Dali::DaliException e) {
77575       {
77576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77577       };
77578     } catch (...) {
77579       {
77580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77581       };
77582     }
77583   }
77584
77585   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77586   return jresult;
77587 }
77588
77589
77590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
77591   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
77592   Dali::Actor arg2 ;
77593   unsigned int arg3 ;
77594   Dali::Actor *argp2 ;
77595
77596   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
77597   argp2 = (Dali::Actor *)jarg2;
77598   if (!argp2) {
77599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77600     return ;
77601   }
77602   arg2 = *argp2;
77603   arg3 = (unsigned int)jarg3;
77604   {
77605     try {
77606       (arg1)->ApplyToPage(arg2,arg3);
77607     } catch (std::out_of_range& e) {
77608       {
77609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77610       };
77611     } catch (std::exception& e) {
77612       {
77613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77614       };
77615     } catch (Dali::DaliException e) {
77616       {
77617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77618       };
77619     } catch (...) {
77620       {
77621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77622       };
77623     }
77624   }
77625
77626 }
77627
77628
77629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
77630   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
77631
77632   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
77633   {
77634     try {
77635       delete arg1;
77636     } catch (std::out_of_range& e) {
77637       {
77638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77639       };
77640     } catch (std::exception& e) {
77641       {
77642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77643       };
77644     } catch (Dali::DaliException e) {
77645       {
77646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77647       };
77648     } catch (...) {
77649       {
77650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77651       };
77652     }
77653   }
77654
77655 }
77656
77657
77658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
77659   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77660   Dali::Toolkit::ClampState arg2 ;
77661
77662   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77663   arg2 = (Dali::Toolkit::ClampState)jarg2;
77664   if (arg1) (arg1)->x = arg2;
77665 }
77666
77667
77668 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
77669   int jresult ;
77670   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77671   Dali::Toolkit::ClampState result;
77672
77673   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77674   result = (Dali::Toolkit::ClampState) ((arg1)->x);
77675   jresult = (int)result;
77676   return jresult;
77677 }
77678
77679
77680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
77681   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77682   Dali::Toolkit::ClampState arg2 ;
77683
77684   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77685   arg2 = (Dali::Toolkit::ClampState)jarg2;
77686   if (arg1) (arg1)->y = arg2;
77687 }
77688
77689
77690 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
77691   int jresult ;
77692   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77693   Dali::Toolkit::ClampState result;
77694
77695   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77696   result = (Dali::Toolkit::ClampState) ((arg1)->y);
77697   jresult = (int)result;
77698   return jresult;
77699 }
77700
77701
77702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
77703   void * jresult ;
77704   Dali::Toolkit::ClampState2D *result = 0 ;
77705
77706   {
77707     try {
77708       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
77709     } catch (std::out_of_range& e) {
77710       {
77711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77712       };
77713     } catch (std::exception& e) {
77714       {
77715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77716       };
77717     } catch (Dali::DaliException e) {
77718       {
77719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77720       };
77721     } catch (...) {
77722       {
77723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77724       };
77725     }
77726   }
77727
77728   jresult = (void *)result;
77729   return jresult;
77730 }
77731
77732
77733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
77734   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77735
77736   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77737   {
77738     try {
77739       delete arg1;
77740     } catch (std::out_of_range& e) {
77741       {
77742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77743       };
77744     } catch (std::exception& e) {
77745       {
77746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77747       };
77748     } catch (Dali::DaliException e) {
77749       {
77750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77751       };
77752     } catch (...) {
77753       {
77754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77755       };
77756     }
77757   }
77758
77759 }
77760
77761
77762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
77763   void * jresult ;
77764   float arg1 ;
77765   float arg2 ;
77766   bool arg3 ;
77767   Dali::Toolkit::RulerDomain *result = 0 ;
77768
77769   arg1 = (float)jarg1;
77770   arg2 = (float)jarg2;
77771   arg3 = jarg3 ? true : false;
77772   {
77773     try {
77774       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
77775     } catch (std::out_of_range& e) {
77776       {
77777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77778       };
77779     } catch (std::exception& e) {
77780       {
77781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77782       };
77783     } catch (Dali::DaliException e) {
77784       {
77785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77786       };
77787     } catch (...) {
77788       {
77789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77790       };
77791     }
77792   }
77793
77794   jresult = (void *)result;
77795   return jresult;
77796 }
77797
77798
77799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
77800   void * jresult ;
77801   float arg1 ;
77802   float arg2 ;
77803   Dali::Toolkit::RulerDomain *result = 0 ;
77804
77805   arg1 = (float)jarg1;
77806   arg2 = (float)jarg2;
77807   {
77808     try {
77809       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
77810     } catch (std::out_of_range& e) {
77811       {
77812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77813       };
77814     } catch (std::exception& e) {
77815       {
77816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77817       };
77818     } catch (Dali::DaliException e) {
77819       {
77820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77821       };
77822     } catch (...) {
77823       {
77824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77825       };
77826     }
77827   }
77828
77829   jresult = (void *)result;
77830   return jresult;
77831 }
77832
77833
77834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
77835   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77836   float arg2 ;
77837
77838   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77839   arg2 = (float)jarg2;
77840   if (arg1) (arg1)->min = arg2;
77841 }
77842
77843
77844 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
77845   float jresult ;
77846   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77847   float result;
77848
77849   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77850   result = (float) ((arg1)->min);
77851   jresult = result;
77852   return jresult;
77853 }
77854
77855
77856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
77857   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77858   float arg2 ;
77859
77860   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77861   arg2 = (float)jarg2;
77862   if (arg1) (arg1)->max = arg2;
77863 }
77864
77865
77866 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
77867   float jresult ;
77868   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77869   float result;
77870
77871   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77872   result = (float) ((arg1)->max);
77873   jresult = result;
77874   return jresult;
77875 }
77876
77877
77878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
77879   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77880   bool arg2 ;
77881
77882   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77883   arg2 = jarg2 ? true : false;
77884   if (arg1) (arg1)->enabled = arg2;
77885 }
77886
77887
77888 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
77889   unsigned int jresult ;
77890   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77891   bool result;
77892
77893   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77894   result = (bool) ((arg1)->enabled);
77895   jresult = result;
77896   return jresult;
77897 }
77898
77899
77900 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
77901   float jresult ;
77902   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77903   float arg2 ;
77904   float arg3 ;
77905   float arg4 ;
77906   float result;
77907
77908   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77909   arg2 = (float)jarg2;
77910   arg3 = (float)jarg3;
77911   arg4 = (float)jarg4;
77912   {
77913     try {
77914       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
77915     } catch (std::out_of_range& e) {
77916       {
77917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77918       };
77919     } catch (std::exception& e) {
77920       {
77921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77922       };
77923     } catch (Dali::DaliException e) {
77924       {
77925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77926       };
77927     } catch (...) {
77928       {
77929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77930       };
77931     }
77932   }
77933
77934   jresult = result;
77935   return jresult;
77936 }
77937
77938
77939 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
77940   float jresult ;
77941   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77942   float arg2 ;
77943   float arg3 ;
77944   float result;
77945
77946   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77947   arg2 = (float)jarg2;
77948   arg3 = (float)jarg3;
77949   {
77950     try {
77951       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
77952     } catch (std::out_of_range& e) {
77953       {
77954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77955       };
77956     } catch (std::exception& e) {
77957       {
77958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77959       };
77960     } catch (Dali::DaliException e) {
77961       {
77962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77963       };
77964     } catch (...) {
77965       {
77966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77967       };
77968     }
77969   }
77970
77971   jresult = result;
77972   return jresult;
77973 }
77974
77975
77976 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
77977   float jresult ;
77978   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77979   float arg2 ;
77980   float result;
77981
77982   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77983   arg2 = (float)jarg2;
77984   {
77985     try {
77986       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
77987     } catch (std::out_of_range& e) {
77988       {
77989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77990       };
77991     } catch (std::exception& e) {
77992       {
77993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77994       };
77995     } catch (Dali::DaliException e) {
77996       {
77997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77998       };
77999     } catch (...) {
78000       {
78001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78002       };
78003     }
78004   }
78005
78006   jresult = result;
78007   return jresult;
78008 }
78009
78010
78011 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
78012   float jresult ;
78013   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78014   float arg2 ;
78015   float arg3 ;
78016   float arg4 ;
78017   Dali::Toolkit::ClampState *arg5 = 0 ;
78018   float result;
78019
78020   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78021   arg2 = (float)jarg2;
78022   arg3 = (float)jarg3;
78023   arg4 = (float)jarg4;
78024   arg5 = (Dali::Toolkit::ClampState *)jarg5;
78025   if (!arg5) {
78026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78027     return 0;
78028   }
78029   {
78030     try {
78031       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
78032     } catch (std::out_of_range& e) {
78033       {
78034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78035       };
78036     } catch (std::exception& e) {
78037       {
78038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78039       };
78040     } catch (Dali::DaliException e) {
78041       {
78042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78043       };
78044     } catch (...) {
78045       {
78046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78047       };
78048     }
78049   }
78050
78051   jresult = result;
78052   return jresult;
78053 }
78054
78055
78056 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
78057   float jresult ;
78058   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78059   float result;
78060
78061   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78062   {
78063     try {
78064       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
78065     } catch (std::out_of_range& e) {
78066       {
78067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78068       };
78069     } catch (std::exception& e) {
78070       {
78071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78072       };
78073     } catch (Dali::DaliException e) {
78074       {
78075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78076       };
78077     } catch (...) {
78078       {
78079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78080       };
78081     }
78082   }
78083
78084   jresult = result;
78085   return jresult;
78086 }
78087
78088
78089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
78090   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78091
78092   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78093   {
78094     try {
78095       delete arg1;
78096     } catch (std::out_of_range& e) {
78097       {
78098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78099       };
78100     } catch (std::exception& e) {
78101       {
78102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78103       };
78104     } catch (Dali::DaliException e) {
78105       {
78106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78107       };
78108     } catch (...) {
78109       {
78110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78111       };
78112     }
78113   }
78114
78115 }
78116
78117
78118 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
78119   float jresult ;
78120   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78121   float arg2 ;
78122   float arg3 ;
78123   float result;
78124
78125   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78126   arg2 = (float)jarg2;
78127   arg3 = (float)jarg3;
78128   {
78129     try {
78130       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
78131     } catch (std::out_of_range& e) {
78132       {
78133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78134       };
78135     } catch (std::exception& e) {
78136       {
78137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78138       };
78139     } catch (Dali::DaliException e) {
78140       {
78141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78142       };
78143     } catch (...) {
78144       {
78145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78146       };
78147     }
78148   }
78149
78150   jresult = result;
78151   return jresult;
78152 }
78153
78154
78155 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
78156   float jresult ;
78157   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78158   float arg2 ;
78159   float result;
78160
78161   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78162   arg2 = (float)jarg2;
78163   {
78164     try {
78165       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
78166     } catch (std::out_of_range& e) {
78167       {
78168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78169       };
78170     } catch (std::exception& e) {
78171       {
78172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78173       };
78174     } catch (Dali::DaliException e) {
78175       {
78176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78177       };
78178     } catch (...) {
78179       {
78180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78181       };
78182     }
78183   }
78184
78185   jresult = result;
78186   return jresult;
78187 }
78188
78189
78190 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78191   float jresult ;
78192   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78193   unsigned int arg2 ;
78194   unsigned int *arg3 = 0 ;
78195   bool arg4 ;
78196   float result;
78197
78198   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78199   arg2 = (unsigned int)jarg2;
78200   arg3 = (unsigned int *)jarg3;
78201   arg4 = jarg4 ? true : false;
78202   {
78203     try {
78204       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78205     } catch (std::out_of_range& e) {
78206       {
78207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78208       };
78209     } catch (std::exception& e) {
78210       {
78211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78212       };
78213     } catch (Dali::DaliException e) {
78214       {
78215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78216       };
78217     } catch (...) {
78218       {
78219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78220       };
78221     }
78222   }
78223
78224   jresult = result;
78225   return jresult;
78226 }
78227
78228
78229 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78230   unsigned int jresult ;
78231   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78232   float arg2 ;
78233   bool arg3 ;
78234   unsigned int result;
78235
78236   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78237   arg2 = (float)jarg2;
78238   arg3 = jarg3 ? true : false;
78239   {
78240     try {
78241       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
78242     } catch (std::out_of_range& e) {
78243       {
78244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78245       };
78246     } catch (std::exception& e) {
78247       {
78248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78249       };
78250     } catch (Dali::DaliException e) {
78251       {
78252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78253       };
78254     } catch (...) {
78255       {
78256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78257       };
78258     }
78259   }
78260
78261   jresult = result;
78262   return jresult;
78263 }
78264
78265
78266 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
78267   unsigned int jresult ;
78268   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78269   unsigned int result;
78270
78271   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78272   {
78273     try {
78274       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
78275     } catch (std::out_of_range& e) {
78276       {
78277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78278       };
78279     } catch (std::exception& e) {
78280       {
78281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78282       };
78283     } catch (Dali::DaliException e) {
78284       {
78285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78286       };
78287     } catch (...) {
78288       {
78289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78290       };
78291     }
78292   }
78293
78294   jresult = result;
78295   return jresult;
78296 }
78297
78298
78299 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
78300   int jresult ;
78301   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78302   Dali::Toolkit::Ruler::RulerType result;
78303
78304   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78305   {
78306     try {
78307       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
78308     } catch (std::out_of_range& e) {
78309       {
78310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78311       };
78312     } catch (std::exception& e) {
78313       {
78314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78315       };
78316     } catch (Dali::DaliException e) {
78317       {
78318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78319       };
78320     } catch (...) {
78321       {
78322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78323       };
78324     }
78325   }
78326
78327   jresult = (int)result;
78328   return jresult;
78329 }
78330
78331
78332 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
78333   unsigned int jresult ;
78334   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78335   bool result;
78336
78337   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78338   {
78339     try {
78340       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
78341     } catch (std::out_of_range& e) {
78342       {
78343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78344       };
78345     } catch (std::exception& e) {
78346       {
78347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78348       };
78349     } catch (Dali::DaliException e) {
78350       {
78351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78352       };
78353     } catch (...) {
78354       {
78355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78356       };
78357     }
78358   }
78359
78360   jresult = result;
78361   return jresult;
78362 }
78363
78364
78365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
78366   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78367
78368   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78369   {
78370     try {
78371       (arg1)->Enable();
78372     } catch (std::out_of_range& e) {
78373       {
78374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78375       };
78376     } catch (std::exception& e) {
78377       {
78378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78379       };
78380     } catch (Dali::DaliException e) {
78381       {
78382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78383       };
78384     } catch (...) {
78385       {
78386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78387       };
78388     }
78389   }
78390
78391 }
78392
78393
78394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
78395   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78396
78397   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78398   {
78399     try {
78400       (arg1)->Disable();
78401     } catch (std::out_of_range& e) {
78402       {
78403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78404       };
78405     } catch (std::exception& e) {
78406       {
78407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78408       };
78409     } catch (Dali::DaliException e) {
78410       {
78411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78412       };
78413     } catch (...) {
78414       {
78415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78416       };
78417     }
78418   }
78419
78420 }
78421
78422
78423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
78424   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78425   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
78426   Dali::Toolkit::RulerDomain *argp2 ;
78427
78428   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78429   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
78430   if (!argp2) {
78431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
78432     return ;
78433   }
78434   arg2 = *argp2;
78435   {
78436     try {
78437       (arg1)->SetDomain(arg2);
78438     } catch (std::out_of_range& e) {
78439       {
78440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78441       };
78442     } catch (std::exception& e) {
78443       {
78444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78445       };
78446     } catch (Dali::DaliException e) {
78447       {
78448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78449       };
78450     } catch (...) {
78451       {
78452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78453       };
78454     }
78455   }
78456
78457 }
78458
78459
78460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
78461   void * jresult ;
78462   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78463   Dali::Toolkit::RulerDomain *result = 0 ;
78464
78465   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78466   {
78467     try {
78468       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
78469     } catch (std::out_of_range& e) {
78470       {
78471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78472       };
78473     } catch (std::exception& e) {
78474       {
78475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78476       };
78477     } catch (Dali::DaliException e) {
78478       {
78479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78480       };
78481     } catch (...) {
78482       {
78483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78484       };
78485     }
78486   }
78487
78488   jresult = (void *)result;
78489   return jresult;
78490 }
78491
78492
78493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
78494   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78495
78496   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78497   {
78498     try {
78499       (arg1)->DisableDomain();
78500     } catch (std::out_of_range& e) {
78501       {
78502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78503       };
78504     } catch (std::exception& e) {
78505       {
78506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78507       };
78508     } catch (Dali::DaliException e) {
78509       {
78510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78511       };
78512     } catch (...) {
78513       {
78514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78515       };
78516     }
78517   }
78518
78519 }
78520
78521
78522 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
78523   float jresult ;
78524   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78525   float arg2 ;
78526   float arg3 ;
78527   float arg4 ;
78528   float result;
78529
78530   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78531   arg2 = (float)jarg2;
78532   arg3 = (float)jarg3;
78533   arg4 = (float)jarg4;
78534   {
78535     try {
78536       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
78537     } catch (std::out_of_range& e) {
78538       {
78539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78540       };
78541     } catch (std::exception& e) {
78542       {
78543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78544       };
78545     } catch (Dali::DaliException e) {
78546       {
78547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78548       };
78549     } catch (...) {
78550       {
78551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78552       };
78553     }
78554   }
78555
78556   jresult = result;
78557   return jresult;
78558 }
78559
78560
78561 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
78562   float jresult ;
78563   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78564   float arg2 ;
78565   float arg3 ;
78566   float result;
78567
78568   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78569   arg2 = (float)jarg2;
78570   arg3 = (float)jarg3;
78571   {
78572     try {
78573       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
78574     } catch (std::out_of_range& e) {
78575       {
78576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78577       };
78578     } catch (std::exception& e) {
78579       {
78580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78581       };
78582     } catch (Dali::DaliException e) {
78583       {
78584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78585       };
78586     } catch (...) {
78587       {
78588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78589       };
78590     }
78591   }
78592
78593   jresult = result;
78594   return jresult;
78595 }
78596
78597
78598 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
78599   float jresult ;
78600   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78601   float arg2 ;
78602   float result;
78603
78604   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78605   arg2 = (float)jarg2;
78606   {
78607     try {
78608       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
78609     } catch (std::out_of_range& e) {
78610       {
78611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78612       };
78613     } catch (std::exception& e) {
78614       {
78615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78616       };
78617     } catch (Dali::DaliException e) {
78618       {
78619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78620       };
78621     } catch (...) {
78622       {
78623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78624       };
78625     }
78626   }
78627
78628   jresult = result;
78629   return jresult;
78630 }
78631
78632
78633 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
78634   float jresult ;
78635   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78636   float arg2 ;
78637   float arg3 ;
78638   float arg4 ;
78639   Dali::Toolkit::ClampState *arg5 = 0 ;
78640   float result;
78641
78642   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78643   arg2 = (float)jarg2;
78644   arg3 = (float)jarg3;
78645   arg4 = (float)jarg4;
78646   arg5 = (Dali::Toolkit::ClampState *)jarg5;
78647   if (!arg5) {
78648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78649     return 0;
78650   }
78651   {
78652     try {
78653       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
78654     } catch (std::out_of_range& e) {
78655       {
78656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78657       };
78658     } catch (std::exception& e) {
78659       {
78660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78661       };
78662     } catch (Dali::DaliException e) {
78663       {
78664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78665       };
78666     } catch (...) {
78667       {
78668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78669       };
78670     }
78671   }
78672
78673   jresult = result;
78674   return jresult;
78675 }
78676
78677
78678 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
78679   float jresult ;
78680   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78681   float arg2 ;
78682   float arg3 ;
78683   float arg4 ;
78684   float arg5 ;
78685   float result;
78686
78687   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78688   arg2 = (float)jarg2;
78689   arg3 = (float)jarg3;
78690   arg4 = (float)jarg4;
78691   arg5 = (float)jarg5;
78692   {
78693     try {
78694       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
78695     } catch (std::out_of_range& e) {
78696       {
78697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78698       };
78699     } catch (std::exception& e) {
78700       {
78701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78702       };
78703     } catch (Dali::DaliException e) {
78704       {
78705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78706       };
78707     } catch (...) {
78708       {
78709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78710       };
78711     }
78712   }
78713
78714   jresult = result;
78715   return jresult;
78716 }
78717
78718
78719 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
78720   float jresult ;
78721   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78722   float arg2 ;
78723   float arg3 ;
78724   float arg4 ;
78725   float result;
78726
78727   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78728   arg2 = (float)jarg2;
78729   arg3 = (float)jarg3;
78730   arg4 = (float)jarg4;
78731   {
78732     try {
78733       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
78734     } catch (std::out_of_range& e) {
78735       {
78736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78737       };
78738     } catch (std::exception& e) {
78739       {
78740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78741       };
78742     } catch (Dali::DaliException e) {
78743       {
78744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78745       };
78746     } catch (...) {
78747       {
78748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78749       };
78750     }
78751   }
78752
78753   jresult = result;
78754   return jresult;
78755 }
78756
78757
78758 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
78759   float jresult ;
78760   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78761   float arg2 ;
78762   float arg3 ;
78763   float result;
78764
78765   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78766   arg2 = (float)jarg2;
78767   arg3 = (float)jarg3;
78768   {
78769     try {
78770       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
78771     } catch (std::out_of_range& e) {
78772       {
78773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78774       };
78775     } catch (std::exception& e) {
78776       {
78777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78778       };
78779     } catch (Dali::DaliException e) {
78780       {
78781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78782       };
78783     } catch (...) {
78784       {
78785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78786       };
78787     }
78788   }
78789
78790   jresult = result;
78791   return jresult;
78792 }
78793
78794
78795 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
78796   float jresult ;
78797   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78798   float arg2 ;
78799   float result;
78800
78801   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78802   arg2 = (float)jarg2;
78803   {
78804     try {
78805       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
78806     } catch (std::out_of_range& e) {
78807       {
78808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78809       };
78810     } catch (std::exception& e) {
78811       {
78812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78813       };
78814     } catch (Dali::DaliException e) {
78815       {
78816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78817       };
78818     } catch (...) {
78819       {
78820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78821       };
78822     }
78823   }
78824
78825   jresult = result;
78826   return jresult;
78827 }
78828
78829
78830 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
78831   float jresult ;
78832   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78833   float arg2 ;
78834   float arg3 ;
78835   float arg4 ;
78836   float arg5 ;
78837   Dali::Toolkit::ClampState *arg6 = 0 ;
78838   float result;
78839
78840   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78841   arg2 = (float)jarg2;
78842   arg3 = (float)jarg3;
78843   arg4 = (float)jarg4;
78844   arg5 = (float)jarg5;
78845   arg6 = (Dali::Toolkit::ClampState *)jarg6;
78846   if (!arg6) {
78847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78848     return 0;
78849   }
78850   {
78851     try {
78852       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
78853     } catch (std::out_of_range& e) {
78854       {
78855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78856       };
78857     } catch (std::exception& e) {
78858       {
78859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78860       };
78861     } catch (Dali::DaliException e) {
78862       {
78863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78864       };
78865     } catch (...) {
78866       {
78867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78868       };
78869     }
78870   }
78871
78872   jresult = result;
78873   return jresult;
78874 }
78875
78876
78877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
78878   void * jresult ;
78879   Dali::Toolkit::DefaultRuler *result = 0 ;
78880
78881   {
78882     try {
78883       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
78884     } catch (std::out_of_range& e) {
78885       {
78886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78887       };
78888     } catch (std::exception& e) {
78889       {
78890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78891       };
78892     } catch (Dali::DaliException e) {
78893       {
78894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78895       };
78896     } catch (...) {
78897       {
78898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78899       };
78900     }
78901   }
78902
78903   jresult = (void *)result;
78904   return jresult;
78905 }
78906
78907
78908 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
78909   float jresult ;
78910   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78911   float arg2 ;
78912   float arg3 ;
78913   float result;
78914
78915   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78916   arg2 = (float)jarg2;
78917   arg3 = (float)jarg3;
78918   {
78919     try {
78920       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
78921     } catch (std::out_of_range& e) {
78922       {
78923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78924       };
78925     } catch (std::exception& e) {
78926       {
78927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78928       };
78929     } catch (Dali::DaliException e) {
78930       {
78931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78932       };
78933     } catch (...) {
78934       {
78935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78936       };
78937     }
78938   }
78939
78940   jresult = result;
78941   return jresult;
78942 }
78943
78944
78945 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78946   float jresult ;
78947   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78948   unsigned int arg2 ;
78949   unsigned int *arg3 = 0 ;
78950   bool arg4 ;
78951   float result;
78952
78953   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78954   arg2 = (unsigned int)jarg2;
78955   arg3 = (unsigned int *)jarg3;
78956   arg4 = jarg4 ? true : false;
78957   {
78958     try {
78959       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78960     } catch (std::out_of_range& e) {
78961       {
78962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78963       };
78964     } catch (std::exception& e) {
78965       {
78966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78967       };
78968     } catch (Dali::DaliException e) {
78969       {
78970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78971       };
78972     } catch (...) {
78973       {
78974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78975       };
78976     }
78977   }
78978
78979   jresult = result;
78980   return jresult;
78981 }
78982
78983
78984 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78985   unsigned int jresult ;
78986   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78987   float arg2 ;
78988   bool arg3 ;
78989   unsigned int result;
78990
78991   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78992   arg2 = (float)jarg2;
78993   arg3 = jarg3 ? true : false;
78994   {
78995     try {
78996       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
78997     } catch (std::out_of_range& e) {
78998       {
78999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79000       };
79001     } catch (std::exception& e) {
79002       {
79003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79004       };
79005     } catch (Dali::DaliException e) {
79006       {
79007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79008       };
79009     } catch (...) {
79010       {
79011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79012       };
79013     }
79014   }
79015
79016   jresult = result;
79017   return jresult;
79018 }
79019
79020
79021 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
79022   unsigned int jresult ;
79023   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79024   unsigned int result;
79025
79026   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79027   {
79028     try {
79029       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
79030     } catch (std::out_of_range& e) {
79031       {
79032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79033       };
79034     } catch (std::exception& e) {
79035       {
79036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79037       };
79038     } catch (Dali::DaliException e) {
79039       {
79040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79041       };
79042     } catch (...) {
79043       {
79044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79045       };
79046     }
79047   }
79048
79049   jresult = result;
79050   return jresult;
79051 }
79052
79053
79054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
79055   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79056
79057   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79058   {
79059     try {
79060       delete arg1;
79061     } catch (std::out_of_range& e) {
79062       {
79063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79064       };
79065     } catch (std::exception& e) {
79066       {
79067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79068       };
79069     } catch (Dali::DaliException e) {
79070       {
79071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79072       };
79073     } catch (...) {
79074       {
79075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79076       };
79077     }
79078   }
79079
79080 }
79081
79082
79083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
79084   void * jresult ;
79085   float arg1 ;
79086   Dali::Toolkit::FixedRuler *result = 0 ;
79087
79088   arg1 = (float)jarg1;
79089   {
79090     try {
79091       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
79092     } catch (std::out_of_range& e) {
79093       {
79094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79095       };
79096     } catch (std::exception& e) {
79097       {
79098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79099       };
79100     } catch (Dali::DaliException e) {
79101       {
79102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79103       };
79104     } catch (...) {
79105       {
79106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79107       };
79108     }
79109   }
79110
79111   jresult = (void *)result;
79112   return jresult;
79113 }
79114
79115
79116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
79117   void * jresult ;
79118   Dali::Toolkit::FixedRuler *result = 0 ;
79119
79120   {
79121     try {
79122       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
79123     } catch (std::out_of_range& e) {
79124       {
79125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79126       };
79127     } catch (std::exception& e) {
79128       {
79129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79130       };
79131     } catch (Dali::DaliException e) {
79132       {
79133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79134       };
79135     } catch (...) {
79136       {
79137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79138       };
79139     }
79140   }
79141
79142   jresult = (void *)result;
79143   return jresult;
79144 }
79145
79146
79147 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
79148   float jresult ;
79149   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79150   float arg2 ;
79151   float arg3 ;
79152   float result;
79153
79154   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79155   arg2 = (float)jarg2;
79156   arg3 = (float)jarg3;
79157   {
79158     try {
79159       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
79160     } catch (std::out_of_range& e) {
79161       {
79162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79163       };
79164     } catch (std::exception& e) {
79165       {
79166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79167       };
79168     } catch (Dali::DaliException e) {
79169       {
79170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79171       };
79172     } catch (...) {
79173       {
79174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79175       };
79176     }
79177   }
79178
79179   jresult = result;
79180   return jresult;
79181 }
79182
79183
79184 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
79185   float jresult ;
79186   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79187   unsigned int arg2 ;
79188   unsigned int *arg3 = 0 ;
79189   bool arg4 ;
79190   float result;
79191
79192   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79193   arg2 = (unsigned int)jarg2;
79194   arg3 = (unsigned int *)jarg3;
79195   arg4 = jarg4 ? true : false;
79196   {
79197     try {
79198       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
79199     } catch (std::out_of_range& e) {
79200       {
79201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79202       };
79203     } catch (std::exception& e) {
79204       {
79205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79206       };
79207     } catch (Dali::DaliException e) {
79208       {
79209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79210       };
79211     } catch (...) {
79212       {
79213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79214       };
79215     }
79216   }
79217
79218   jresult = result;
79219   return jresult;
79220 }
79221
79222
79223 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
79224   unsigned int jresult ;
79225   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79226   float arg2 ;
79227   bool arg3 ;
79228   unsigned int result;
79229
79230   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79231   arg2 = (float)jarg2;
79232   arg3 = jarg3 ? true : false;
79233   {
79234     try {
79235       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
79236     } catch (std::out_of_range& e) {
79237       {
79238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79239       };
79240     } catch (std::exception& e) {
79241       {
79242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79243       };
79244     } catch (Dali::DaliException e) {
79245       {
79246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79247       };
79248     } catch (...) {
79249       {
79250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79251       };
79252     }
79253   }
79254
79255   jresult = result;
79256   return jresult;
79257 }
79258
79259
79260 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
79261   unsigned int jresult ;
79262   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79263   unsigned int result;
79264
79265   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79266   {
79267     try {
79268       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
79269     } catch (std::out_of_range& e) {
79270       {
79271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79272       };
79273     } catch (std::exception& e) {
79274       {
79275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79276       };
79277     } catch (Dali::DaliException e) {
79278       {
79279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79280       };
79281     } catch (...) {
79282       {
79283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79284       };
79285     }
79286   }
79287
79288   jresult = result;
79289   return jresult;
79290 }
79291
79292
79293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
79294   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79295
79296   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79297   {
79298     try {
79299       delete arg1;
79300     } catch (std::out_of_range& e) {
79301       {
79302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79303       };
79304     } catch (std::exception& e) {
79305       {
79306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79307       };
79308     } catch (Dali::DaliException e) {
79309       {
79310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79311       };
79312     } catch (...) {
79313       {
79314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79315       };
79316     }
79317   }
79318
79319 }
79320
79321
79322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
79323   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79324   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79325
79326   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79327   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79328   if (arg1) (arg1)->scale = *arg2;
79329 }
79330
79331
79332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
79333   void * jresult ;
79334   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79335   Dali::Toolkit::ClampState2D *result = 0 ;
79336
79337   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79338   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
79339   jresult = (void *)result;
79340   return jresult;
79341 }
79342
79343
79344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
79345   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79346   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79347
79348   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79349   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79350   if (arg1) (arg1)->position = *arg2;
79351 }
79352
79353
79354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
79355   void * jresult ;
79356   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79357   Dali::Toolkit::ClampState2D *result = 0 ;
79358
79359   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79360   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
79361   jresult = (void *)result;
79362   return jresult;
79363 }
79364
79365
79366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
79367   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79368   Dali::Toolkit::ClampState arg2 ;
79369
79370   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79371   arg2 = (Dali::Toolkit::ClampState)jarg2;
79372   if (arg1) (arg1)->rotation = arg2;
79373 }
79374
79375
79376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
79377   int jresult ;
79378   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79379   Dali::Toolkit::ClampState result;
79380
79381   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79382   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
79383   jresult = (int)result;
79384   return jresult;
79385 }
79386
79387
79388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
79389   void * jresult ;
79390   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
79391
79392   {
79393     try {
79394       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
79395     } catch (std::out_of_range& e) {
79396       {
79397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79398       };
79399     } catch (std::exception& e) {
79400       {
79401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79402       };
79403     } catch (Dali::DaliException e) {
79404       {
79405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79406       };
79407     } catch (...) {
79408       {
79409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79410       };
79411     }
79412   }
79413
79414   jresult = (void *)result;
79415   return jresult;
79416 }
79417
79418
79419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
79420   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79421
79422   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79423   {
79424     try {
79425       delete arg1;
79426     } catch (std::out_of_range& e) {
79427       {
79428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79429       };
79430     } catch (std::exception& e) {
79431       {
79432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79433       };
79434     } catch (Dali::DaliException e) {
79435       {
79436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79437       };
79438     } catch (...) {
79439       {
79440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79441       };
79442     }
79443   }
79444
79445 }
79446
79447
79448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
79449   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79450   Dali::Toolkit::SnapType arg2 ;
79451
79452   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79453   arg2 = (Dali::Toolkit::SnapType)jarg2;
79454   if (arg1) (arg1)->type = arg2;
79455 }
79456
79457
79458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
79459   int jresult ;
79460   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79461   Dali::Toolkit::SnapType result;
79462
79463   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79464   result = (Dali::Toolkit::SnapType) ((arg1)->type);
79465   jresult = (int)result;
79466   return jresult;
79467 }
79468
79469
79470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
79471   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79472   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
79473
79474   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79475   arg2 = (Dali::Vector2 *)jarg2;
79476   if (arg1) (arg1)->position = *arg2;
79477 }
79478
79479
79480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
79481   void * jresult ;
79482   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79483   Dali::Vector2 *result = 0 ;
79484
79485   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79486   result = (Dali::Vector2 *)& ((arg1)->position);
79487   jresult = (void *)result;
79488   return jresult;
79489 }
79490
79491
79492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
79493   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79494   float arg2 ;
79495
79496   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79497   arg2 = (float)jarg2;
79498   if (arg1) (arg1)->duration = arg2;
79499 }
79500
79501
79502 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
79503   float jresult ;
79504   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79505   float result;
79506
79507   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79508   result = (float) ((arg1)->duration);
79509   jresult = result;
79510   return jresult;
79511 }
79512
79513
79514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
79515   void * jresult ;
79516   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
79517
79518   {
79519     try {
79520       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
79521     } catch (std::out_of_range& e) {
79522       {
79523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79524       };
79525     } catch (std::exception& e) {
79526       {
79527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79528       };
79529     } catch (Dali::DaliException e) {
79530       {
79531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79532       };
79533     } catch (...) {
79534       {
79535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79536       };
79537     }
79538   }
79539
79540   jresult = (void *)result;
79541   return jresult;
79542 }
79543
79544
79545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
79546   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79547
79548   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79549   {
79550     try {
79551       delete arg1;
79552     } catch (std::out_of_range& e) {
79553       {
79554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79555       };
79556     } catch (std::exception& e) {
79557       {
79558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79559       };
79560     } catch (Dali::DaliException e) {
79561       {
79562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79563       };
79564     } catch (...) {
79565       {
79566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79567       };
79568     }
79569   }
79570
79571 }
79572
79573
79574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
79575   int jresult ;
79576   int result;
79577
79578   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
79579   jresult = (int)result;
79580   return jresult;
79581 }
79582
79583
79584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
79585   int jresult ;
79586   int result;
79587
79588   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
79589   jresult = (int)result;
79590   return jresult;
79591 }
79592
79593
79594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
79595   int jresult ;
79596   int result;
79597
79598   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
79599   jresult = (int)result;
79600   return jresult;
79601 }
79602
79603
79604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
79605   int jresult ;
79606   int result;
79607
79608   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
79609   jresult = (int)result;
79610   return jresult;
79611 }
79612
79613
79614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
79615   int jresult ;
79616   int result;
79617
79618   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
79619   jresult = (int)result;
79620   return jresult;
79621 }
79622
79623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
79624   int jresult ;
79625   int result;
79626
79627   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
79628   jresult = (int)result;
79629   return jresult;
79630 }
79631
79632
79633 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
79634   int jresult ;
79635   int result;
79636
79637   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
79638   jresult = (int)result;
79639   return jresult;
79640 }
79641
79642
79643 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
79644   int jresult ;
79645   int result;
79646
79647   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
79648   jresult = (int)result;
79649   return jresult;
79650 }
79651
79652
79653 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
79654   int jresult ;
79655   int result;
79656
79657   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
79658   jresult = (int)result;
79659   return jresult;
79660 }
79661
79662
79663 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
79664   int jresult ;
79665   int result;
79666
79667   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
79668   jresult = (int)result;
79669   return jresult;
79670 }
79671
79672
79673 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
79674   int jresult ;
79675   int result;
79676
79677   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
79678   jresult = (int)result;
79679   return jresult;
79680 }
79681
79682
79683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
79684   int jresult ;
79685   int result;
79686
79687   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
79688   jresult = (int)result;
79689   return jresult;
79690 }
79691
79692
79693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
79694   int jresult ;
79695   int result;
79696
79697   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
79698   jresult = (int)result;
79699   return jresult;
79700 }
79701
79702
79703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
79704   int jresult ;
79705   int result;
79706
79707   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
79708   jresult = (int)result;
79709   return jresult;
79710 }
79711
79712
79713 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
79714   int jresult ;
79715   int result;
79716
79717   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
79718   jresult = (int)result;
79719   return jresult;
79720 }
79721
79722
79723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
79724   int jresult ;
79725   int result;
79726
79727   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
79728   jresult = (int)result;
79729   return jresult;
79730 }
79731
79732
79733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
79734   int jresult ;
79735   int result;
79736
79737   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
79738   jresult = (int)result;
79739   return jresult;
79740 }
79741
79742
79743 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
79744   int jresult ;
79745   int result;
79746
79747   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
79748   jresult = (int)result;
79749   return jresult;
79750 }
79751
79752
79753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
79754   int jresult ;
79755   int result;
79756
79757   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
79758   jresult = (int)result;
79759   return jresult;
79760 }
79761
79762
79763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
79764   int jresult ;
79765   int result;
79766
79767   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
79768   jresult = (int)result;
79769   return jresult;
79770 }
79771
79772
79773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
79774   int jresult ;
79775   int result;
79776
79777   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
79778   jresult = (int)result;
79779   return jresult;
79780 }
79781
79782
79783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
79784   int jresult ;
79785   int result;
79786
79787   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
79788   jresult = (int)result;
79789   return jresult;
79790 }
79791
79792
79793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
79794   int jresult ;
79795   int result;
79796
79797   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
79798   jresult = (int)result;
79799   return jresult;
79800 }
79801
79802
79803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
79804   int jresult ;
79805   int result;
79806
79807   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
79808   jresult = (int)result;
79809   return jresult;
79810 }
79811
79812
79813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
79814   int jresult ;
79815   int result;
79816
79817   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
79818   jresult = (int)result;
79819   return jresult;
79820 }
79821
79822
79823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
79824   int jresult ;
79825   int result;
79826
79827   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
79828   jresult = (int)result;
79829   return jresult;
79830 }
79831
79832
79833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
79834   void * jresult ;
79835   Dali::Toolkit::ScrollView::Property *result = 0 ;
79836
79837   {
79838     try {
79839       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
79840     } catch (std::out_of_range& e) {
79841       {
79842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79843       };
79844     } catch (std::exception& e) {
79845       {
79846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79847       };
79848     } catch (Dali::DaliException e) {
79849       {
79850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79851       };
79852     } catch (...) {
79853       {
79854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79855       };
79856     }
79857   }
79858
79859   jresult = (void *)result;
79860   return jresult;
79861 }
79862
79863
79864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
79865   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
79866
79867   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
79868   {
79869     try {
79870       delete arg1;
79871     } catch (std::out_of_range& e) {
79872       {
79873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79874       };
79875     } catch (std::exception& e) {
79876       {
79877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79878       };
79879     } catch (Dali::DaliException e) {
79880       {
79881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79882       };
79883     } catch (...) {
79884       {
79885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79886       };
79887     }
79888   }
79889
79890 }
79891
79892
79893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
79894   void * jresult ;
79895   Dali::Toolkit::ScrollView *result = 0 ;
79896
79897   {
79898     try {
79899       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
79900     } catch (std::out_of_range& e) {
79901       {
79902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79903       };
79904     } catch (std::exception& e) {
79905       {
79906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79907       };
79908     } catch (Dali::DaliException e) {
79909       {
79910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79911       };
79912     } catch (...) {
79913       {
79914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79915       };
79916     }
79917   }
79918
79919   jresult = (void *)result;
79920   return jresult;
79921 }
79922
79923
79924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
79925   void * jresult ;
79926   Dali::Toolkit::ScrollView *arg1 = 0 ;
79927   Dali::Toolkit::ScrollView *result = 0 ;
79928
79929   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79930   if (!arg1) {
79931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
79932     return 0;
79933   }
79934   {
79935     try {
79936       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
79937     } catch (std::out_of_range& e) {
79938       {
79939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79940       };
79941     } catch (std::exception& e) {
79942       {
79943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79944       };
79945     } catch (Dali::DaliException e) {
79946       {
79947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79948       };
79949     } catch (...) {
79950       {
79951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79952       };
79953     }
79954   }
79955
79956   jresult = (void *)result;
79957   return jresult;
79958 }
79959
79960
79961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
79962   void * jresult ;
79963   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79964   Dali::Toolkit::ScrollView *arg2 = 0 ;
79965   Dali::Toolkit::ScrollView *result = 0 ;
79966
79967   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79968   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
79969   if (!arg2) {
79970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
79971     return 0;
79972   }
79973   {
79974     try {
79975       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
79976     } catch (std::out_of_range& e) {
79977       {
79978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79979       };
79980     } catch (std::exception& e) {
79981       {
79982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79983       };
79984     } catch (Dali::DaliException e) {
79985       {
79986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79987       };
79988     } catch (...) {
79989       {
79990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79991       };
79992     }
79993   }
79994
79995   jresult = (void *)result;
79996   return jresult;
79997 }
79998
79999
80000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
80001   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80002
80003   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80004   {
80005     try {
80006       delete arg1;
80007     } catch (std::out_of_range& e) {
80008       {
80009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80010       };
80011     } catch (std::exception& e) {
80012       {
80013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80014       };
80015     } catch (Dali::DaliException e) {
80016       {
80017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80018       };
80019     } catch (...) {
80020       {
80021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80022       };
80023     }
80024   }
80025
80026 }
80027
80028
80029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
80030   void * jresult ;
80031   Dali::Toolkit::ScrollView result;
80032
80033   {
80034     try {
80035       result = Dali::Toolkit::ScrollView::New();
80036     } catch (std::out_of_range& e) {
80037       {
80038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80039       };
80040     } catch (std::exception& e) {
80041       {
80042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80043       };
80044     } catch (Dali::DaliException e) {
80045       {
80046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80047       };
80048     } catch (...) {
80049       {
80050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80051       };
80052     }
80053   }
80054
80055   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
80056   return jresult;
80057 }
80058
80059
80060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
80061   void * jresult ;
80062   Dali::BaseHandle arg1 ;
80063   Dali::BaseHandle *argp1 ;
80064   Dali::Toolkit::ScrollView result;
80065
80066   argp1 = (Dali::BaseHandle *)jarg1;
80067   if (!argp1) {
80068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
80069     return 0;
80070   }
80071   arg1 = *argp1;
80072   {
80073     try {
80074       result = Dali::Toolkit::ScrollView::DownCast(arg1);
80075     } catch (std::out_of_range& e) {
80076       {
80077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80078       };
80079     } catch (std::exception& e) {
80080       {
80081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80082       };
80083     } catch (Dali::DaliException e) {
80084       {
80085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80086       };
80087     } catch (...) {
80088       {
80089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80090       };
80091     }
80092   }
80093
80094   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
80095   return jresult;
80096 }
80097
80098
80099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
80100   void * jresult ;
80101   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80102   Dali::AlphaFunction result;
80103
80104   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80105   {
80106     try {
80107       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
80108     } catch (std::out_of_range& e) {
80109       {
80110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80111       };
80112     } catch (std::exception& e) {
80113       {
80114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80115       };
80116     } catch (Dali::DaliException e) {
80117       {
80118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80119       };
80120     } catch (...) {
80121       {
80122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80123       };
80124     }
80125   }
80126
80127   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80128   return jresult;
80129 }
80130
80131
80132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
80133   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80134   Dali::AlphaFunction arg2 ;
80135   Dali::AlphaFunction *argp2 ;
80136
80137   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80138   argp2 = (Dali::AlphaFunction *)jarg2;
80139   if (!argp2) {
80140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80141     return ;
80142   }
80143   arg2 = *argp2;
80144   {
80145     try {
80146       (arg1)->SetScrollSnapAlphaFunction(arg2);
80147     } catch (std::out_of_range& e) {
80148       {
80149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80150       };
80151     } catch (std::exception& e) {
80152       {
80153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80154       };
80155     } catch (Dali::DaliException e) {
80156       {
80157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80158       };
80159     } catch (...) {
80160       {
80161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80162       };
80163     }
80164   }
80165
80166 }
80167
80168
80169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
80170   void * jresult ;
80171   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80172   Dali::AlphaFunction result;
80173
80174   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80175   {
80176     try {
80177       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
80178     } catch (std::out_of_range& e) {
80179       {
80180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80181       };
80182     } catch (std::exception& e) {
80183       {
80184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80185       };
80186     } catch (Dali::DaliException e) {
80187       {
80188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80189       };
80190     } catch (...) {
80191       {
80192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80193       };
80194     }
80195   }
80196
80197   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80198   return jresult;
80199 }
80200
80201
80202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
80203   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80204   Dali::AlphaFunction arg2 ;
80205   Dali::AlphaFunction *argp2 ;
80206
80207   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80208   argp2 = (Dali::AlphaFunction *)jarg2;
80209   if (!argp2) {
80210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80211     return ;
80212   }
80213   arg2 = *argp2;
80214   {
80215     try {
80216       (arg1)->SetScrollFlickAlphaFunction(arg2);
80217     } catch (std::out_of_range& e) {
80218       {
80219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80220       };
80221     } catch (std::exception& e) {
80222       {
80223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80224       };
80225     } catch (Dali::DaliException e) {
80226       {
80227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80228       };
80229     } catch (...) {
80230       {
80231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80232       };
80233     }
80234   }
80235
80236 }
80237
80238
80239 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
80240   float jresult ;
80241   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80242   float result;
80243
80244   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80245   {
80246     try {
80247       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
80248     } catch (std::out_of_range& e) {
80249       {
80250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80251       };
80252     } catch (std::exception& e) {
80253       {
80254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80255       };
80256     } catch (Dali::DaliException e) {
80257       {
80258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80259       };
80260     } catch (...) {
80261       {
80262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80263       };
80264     }
80265   }
80266
80267   jresult = result;
80268   return jresult;
80269 }
80270
80271
80272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
80273   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80274   float arg2 ;
80275
80276   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80277   arg2 = (float)jarg2;
80278   {
80279     try {
80280       (arg1)->SetScrollSnapDuration(arg2);
80281     } catch (std::out_of_range& e) {
80282       {
80283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80284       };
80285     } catch (std::exception& e) {
80286       {
80287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80288       };
80289     } catch (Dali::DaliException e) {
80290       {
80291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80292       };
80293     } catch (...) {
80294       {
80295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80296       };
80297     }
80298   }
80299
80300 }
80301
80302
80303 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
80304   float jresult ;
80305   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80306   float result;
80307
80308   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80309   {
80310     try {
80311       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
80312     } catch (std::out_of_range& e) {
80313       {
80314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80315       };
80316     } catch (std::exception& e) {
80317       {
80318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80319       };
80320     } catch (Dali::DaliException e) {
80321       {
80322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80323       };
80324     } catch (...) {
80325       {
80326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80327       };
80328     }
80329   }
80330
80331   jresult = result;
80332   return jresult;
80333 }
80334
80335
80336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
80337   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80338   float arg2 ;
80339
80340   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80341   arg2 = (float)jarg2;
80342   {
80343     try {
80344       (arg1)->SetScrollFlickDuration(arg2);
80345     } catch (std::out_of_range& e) {
80346       {
80347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80348       };
80349     } catch (std::exception& e) {
80350       {
80351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80352       };
80353     } catch (Dali::DaliException e) {
80354       {
80355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80356       };
80357     } catch (...) {
80358       {
80359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80360       };
80361     }
80362   }
80363
80364 }
80365
80366
80367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
80368   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80369   Dali::Toolkit::RulerPtr arg2 ;
80370   Dali::Toolkit::RulerPtr *argp2 ;
80371
80372   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80373   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80374   if (!argp2) {
80375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80376     return ;
80377   }
80378   arg2 = *argp2;
80379   {
80380     try {
80381       (arg1)->SetRulerX(arg2);
80382     } catch (std::out_of_range& e) {
80383       {
80384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80385       };
80386     } catch (std::exception& e) {
80387       {
80388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80389       };
80390     } catch (Dali::DaliException e) {
80391       {
80392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80393       };
80394     } catch (...) {
80395       {
80396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80397       };
80398     }
80399   }
80400
80401 }
80402
80403
80404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
80405   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80406   Dali::Toolkit::RulerPtr arg2 ;
80407   Dali::Toolkit::RulerPtr *argp2 ;
80408
80409   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80410   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80411   if (!argp2) {
80412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80413     return ;
80414   }
80415   arg2 = *argp2;
80416   {
80417     try {
80418       (arg1)->SetRulerY(arg2);
80419     } catch (std::out_of_range& e) {
80420       {
80421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80422       };
80423     } catch (std::exception& e) {
80424       {
80425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80426       };
80427     } catch (Dali::DaliException e) {
80428       {
80429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80430       };
80431     } catch (...) {
80432       {
80433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80434       };
80435     }
80436   }
80437
80438 }
80439
80440
80441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
80442   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80443   bool arg2 ;
80444
80445   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80446   arg2 = jarg2 ? true : false;
80447   {
80448     try {
80449       (arg1)->SetScrollSensitive(arg2);
80450     } catch (std::out_of_range& e) {
80451       {
80452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80453       };
80454     } catch (std::exception& e) {
80455       {
80456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80457       };
80458     } catch (Dali::DaliException e) {
80459       {
80460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80461       };
80462     } catch (...) {
80463       {
80464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80465       };
80466     }
80467   }
80468
80469 }
80470
80471
80472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
80473   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80474   float arg2 ;
80475   float arg3 ;
80476
80477   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80478   arg2 = (float)jarg2;
80479   arg3 = (float)jarg3;
80480   {
80481     try {
80482       (arg1)->SetMaxOvershoot(arg2,arg3);
80483     } catch (std::out_of_range& e) {
80484       {
80485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80486       };
80487     } catch (std::exception& e) {
80488       {
80489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80490       };
80491     } catch (Dali::DaliException e) {
80492       {
80493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80494       };
80495     } catch (...) {
80496       {
80497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80498       };
80499     }
80500   }
80501
80502 }
80503
80504
80505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
80506   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80507   Dali::AlphaFunction arg2 ;
80508   Dali::AlphaFunction *argp2 ;
80509
80510   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80511   argp2 = (Dali::AlphaFunction *)jarg2;
80512   if (!argp2) {
80513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80514     return ;
80515   }
80516   arg2 = *argp2;
80517   {
80518     try {
80519       (arg1)->SetSnapOvershootAlphaFunction(arg2);
80520     } catch (std::out_of_range& e) {
80521       {
80522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80523       };
80524     } catch (std::exception& e) {
80525       {
80526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80527       };
80528     } catch (Dali::DaliException e) {
80529       {
80530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80531       };
80532     } catch (...) {
80533       {
80534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80535       };
80536     }
80537   }
80538
80539 }
80540
80541
80542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
80543   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80544   float arg2 ;
80545
80546   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80547   arg2 = (float)jarg2;
80548   {
80549     try {
80550       (arg1)->SetSnapOvershootDuration(arg2);
80551     } catch (std::out_of_range& e) {
80552       {
80553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80554       };
80555     } catch (std::exception& e) {
80556       {
80557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80558       };
80559     } catch (Dali::DaliException e) {
80560       {
80561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80562       };
80563     } catch (...) {
80564       {
80565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80566       };
80567     }
80568   }
80569
80570 }
80571
80572
80573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
80574   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80575   bool arg2 ;
80576
80577   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80578   arg2 = jarg2 ? true : false;
80579   {
80580     try {
80581       (arg1)->SetActorAutoSnap(arg2);
80582     } catch (std::out_of_range& e) {
80583       {
80584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80585       };
80586     } catch (std::exception& e) {
80587       {
80588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80589       };
80590     } catch (Dali::DaliException e) {
80591       {
80592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80593       };
80594     } catch (...) {
80595       {
80596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80597       };
80598     }
80599   }
80600
80601 }
80602
80603
80604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
80605   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80606   bool arg2 ;
80607
80608   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80609   arg2 = jarg2 ? true : false;
80610   {
80611     try {
80612       (arg1)->SetWrapMode(arg2);
80613     } catch (std::out_of_range& e) {
80614       {
80615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80616       };
80617     } catch (std::exception& e) {
80618       {
80619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80620       };
80621     } catch (Dali::DaliException e) {
80622       {
80623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80624       };
80625     } catch (...) {
80626       {
80627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80628       };
80629     }
80630   }
80631
80632 }
80633
80634
80635 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
80636   int jresult ;
80637   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80638   int result;
80639
80640   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80641   {
80642     try {
80643       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
80644     } catch (std::out_of_range& e) {
80645       {
80646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80647       };
80648     } catch (std::exception& e) {
80649       {
80650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80651       };
80652     } catch (Dali::DaliException e) {
80653       {
80654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80655       };
80656     } catch (...) {
80657       {
80658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80659       };
80660     }
80661   }
80662
80663   jresult = result;
80664   return jresult;
80665 }
80666
80667
80668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
80669   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80670   int arg2 ;
80671
80672   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80673   arg2 = (int)jarg2;
80674   {
80675     try {
80676       (arg1)->SetScrollUpdateDistance(arg2);
80677     } catch (std::out_of_range& e) {
80678       {
80679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80680       };
80681     } catch (std::exception& e) {
80682       {
80683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80684       };
80685     } catch (Dali::DaliException e) {
80686       {
80687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80688       };
80689     } catch (...) {
80690       {
80691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80692       };
80693     }
80694   }
80695
80696 }
80697
80698
80699 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
80700   unsigned int jresult ;
80701   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80702   bool result;
80703
80704   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80705   {
80706     try {
80707       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
80708     } catch (std::out_of_range& e) {
80709       {
80710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80711       };
80712     } catch (std::exception& e) {
80713       {
80714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80715       };
80716     } catch (Dali::DaliException e) {
80717       {
80718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80719       };
80720     } catch (...) {
80721       {
80722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80723       };
80724     }
80725   }
80726
80727   jresult = result;
80728   return jresult;
80729 }
80730
80731
80732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
80733   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80734   bool arg2 ;
80735
80736   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80737   arg2 = jarg2 ? true : false;
80738   {
80739     try {
80740       (arg1)->SetAxisAutoLock(arg2);
80741     } catch (std::out_of_range& e) {
80742       {
80743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80744       };
80745     } catch (std::exception& e) {
80746       {
80747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80748       };
80749     } catch (Dali::DaliException e) {
80750       {
80751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80752       };
80753     } catch (...) {
80754       {
80755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80756       };
80757     }
80758   }
80759
80760 }
80761
80762
80763 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
80764   float jresult ;
80765   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80766   float result;
80767
80768   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80769   {
80770     try {
80771       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
80772     } catch (std::out_of_range& e) {
80773       {
80774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80775       };
80776     } catch (std::exception& e) {
80777       {
80778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80779       };
80780     } catch (Dali::DaliException e) {
80781       {
80782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80783       };
80784     } catch (...) {
80785       {
80786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80787       };
80788     }
80789   }
80790
80791   jresult = result;
80792   return jresult;
80793 }
80794
80795
80796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
80797   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80798   float arg2 ;
80799
80800   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80801   arg2 = (float)jarg2;
80802   {
80803     try {
80804       (arg1)->SetAxisAutoLockGradient(arg2);
80805     } catch (std::out_of_range& e) {
80806       {
80807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80808       };
80809     } catch (std::exception& e) {
80810       {
80811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80812       };
80813     } catch (Dali::DaliException e) {
80814       {
80815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80816       };
80817     } catch (...) {
80818       {
80819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80820       };
80821     }
80822   }
80823
80824 }
80825
80826
80827 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
80828   float jresult ;
80829   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80830   float result;
80831
80832   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80833   {
80834     try {
80835       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
80836     } catch (std::out_of_range& e) {
80837       {
80838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80839       };
80840     } catch (std::exception& e) {
80841       {
80842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80843       };
80844     } catch (Dali::DaliException e) {
80845       {
80846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80847       };
80848     } catch (...) {
80849       {
80850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80851       };
80852     }
80853   }
80854
80855   jresult = result;
80856   return jresult;
80857 }
80858
80859
80860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
80861   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80862   float arg2 ;
80863
80864   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80865   arg2 = (float)jarg2;
80866   {
80867     try {
80868       (arg1)->SetFrictionCoefficient(arg2);
80869     } catch (std::out_of_range& e) {
80870       {
80871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80872       };
80873     } catch (std::exception& e) {
80874       {
80875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80876       };
80877     } catch (Dali::DaliException e) {
80878       {
80879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80880       };
80881     } catch (...) {
80882       {
80883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80884       };
80885     }
80886   }
80887
80888 }
80889
80890
80891 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
80892   float jresult ;
80893   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80894   float result;
80895
80896   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80897   {
80898     try {
80899       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
80900     } catch (std::out_of_range& e) {
80901       {
80902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80903       };
80904     } catch (std::exception& e) {
80905       {
80906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80907       };
80908     } catch (Dali::DaliException e) {
80909       {
80910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80911       };
80912     } catch (...) {
80913       {
80914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80915       };
80916     }
80917   }
80918
80919   jresult = result;
80920   return jresult;
80921 }
80922
80923
80924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
80925   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80926   float arg2 ;
80927
80928   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80929   arg2 = (float)jarg2;
80930   {
80931     try {
80932       (arg1)->SetFlickSpeedCoefficient(arg2);
80933     } catch (std::out_of_range& e) {
80934       {
80935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80936       };
80937     } catch (std::exception& e) {
80938       {
80939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80940       };
80941     } catch (Dali::DaliException e) {
80942       {
80943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80944       };
80945     } catch (...) {
80946       {
80947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80948       };
80949     }
80950   }
80951
80952 }
80953
80954
80955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
80956   void * jresult ;
80957   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80958   Dali::Vector2 result;
80959
80960   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80961   {
80962     try {
80963       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
80964     } catch (std::out_of_range& e) {
80965       {
80966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80967       };
80968     } catch (std::exception& e) {
80969       {
80970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80971       };
80972     } catch (Dali::DaliException e) {
80973       {
80974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80975       };
80976     } catch (...) {
80977       {
80978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80979       };
80980     }
80981   }
80982
80983   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80984   return jresult;
80985 }
80986
80987
80988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
80989   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80990   Dali::Vector2 *arg2 = 0 ;
80991
80992   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80993   arg2 = (Dali::Vector2 *)jarg2;
80994   if (!arg2) {
80995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80996     return ;
80997   }
80998   {
80999     try {
81000       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
81001     } catch (std::out_of_range& e) {
81002       {
81003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81004       };
81005     } catch (std::exception& e) {
81006       {
81007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81008       };
81009     } catch (Dali::DaliException e) {
81010       {
81011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81012       };
81013     } catch (...) {
81014       {
81015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81016       };
81017     }
81018   }
81019
81020 }
81021
81022
81023 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
81024   float jresult ;
81025   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81026   float result;
81027
81028   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81029   {
81030     try {
81031       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
81032     } catch (std::out_of_range& e) {
81033       {
81034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81035       };
81036     } catch (std::exception& e) {
81037       {
81038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81039       };
81040     } catch (Dali::DaliException e) {
81041       {
81042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81043       };
81044     } catch (...) {
81045       {
81046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81047       };
81048     }
81049   }
81050
81051   jresult = result;
81052   return jresult;
81053 }
81054
81055
81056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
81057   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81058   float arg2 ;
81059
81060   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81061   arg2 = (float)jarg2;
81062   {
81063     try {
81064       (arg1)->SetMinimumSpeedForFlick(arg2);
81065     } catch (std::out_of_range& e) {
81066       {
81067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81068       };
81069     } catch (std::exception& e) {
81070       {
81071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81072       };
81073     } catch (Dali::DaliException e) {
81074       {
81075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81076       };
81077     } catch (...) {
81078       {
81079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81080       };
81081     }
81082   }
81083
81084 }
81085
81086
81087 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
81088   float jresult ;
81089   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81090   float result;
81091
81092   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81093   {
81094     try {
81095       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
81096     } catch (std::out_of_range& e) {
81097       {
81098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81099       };
81100     } catch (std::exception& e) {
81101       {
81102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81103       };
81104     } catch (Dali::DaliException e) {
81105       {
81106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81107       };
81108     } catch (...) {
81109       {
81110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81111       };
81112     }
81113   }
81114
81115   jresult = result;
81116   return jresult;
81117 }
81118
81119
81120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
81121   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81122   float arg2 ;
81123
81124   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81125   arg2 = (float)jarg2;
81126   {
81127     try {
81128       (arg1)->SetMaxFlickSpeed(arg2);
81129     } catch (std::out_of_range& e) {
81130       {
81131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81132       };
81133     } catch (std::exception& e) {
81134       {
81135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81136       };
81137     } catch (Dali::DaliException e) {
81138       {
81139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81140       };
81141     } catch (...) {
81142       {
81143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81144       };
81145     }
81146   }
81147
81148 }
81149
81150
81151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
81152   void * jresult ;
81153   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81154   Dali::Vector2 result;
81155
81156   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81157   {
81158     try {
81159       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
81160     } catch (std::out_of_range& e) {
81161       {
81162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81163       };
81164     } catch (std::exception& e) {
81165       {
81166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81167       };
81168     } catch (Dali::DaliException e) {
81169       {
81170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81171       };
81172     } catch (...) {
81173       {
81174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81175       };
81176     }
81177   }
81178
81179   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81180   return jresult;
81181 }
81182
81183
81184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
81185   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81186   Dali::Vector2 arg2 ;
81187   Dali::Vector2 *argp2 ;
81188
81189   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81190   argp2 = (Dali::Vector2 *)jarg2;
81191   if (!argp2) {
81192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
81193     return ;
81194   }
81195   arg2 = *argp2;
81196   {
81197     try {
81198       (arg1)->SetWheelScrollDistanceStep(arg2);
81199     } catch (std::out_of_range& e) {
81200       {
81201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81202       };
81203     } catch (std::exception& e) {
81204       {
81205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81206       };
81207     } catch (Dali::DaliException e) {
81208       {
81209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81210       };
81211     } catch (...) {
81212       {
81213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81214       };
81215     }
81216   }
81217
81218 }
81219
81220
81221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
81222   void * jresult ;
81223   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81224   Dali::Vector2 result;
81225
81226   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81227   {
81228     try {
81229       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
81230     } catch (std::out_of_range& e) {
81231       {
81232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81233       };
81234     } catch (std::exception& e) {
81235       {
81236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81237       };
81238     } catch (Dali::DaliException e) {
81239       {
81240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81241       };
81242     } catch (...) {
81243       {
81244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81245       };
81246     }
81247   }
81248
81249   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81250   return jresult;
81251 }
81252
81253
81254 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
81255   unsigned int jresult ;
81256   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81257   unsigned int result;
81258
81259   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81260   {
81261     try {
81262       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
81263     } catch (std::out_of_range& e) {
81264       {
81265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81266       };
81267     } catch (std::exception& e) {
81268       {
81269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81270       };
81271     } catch (Dali::DaliException e) {
81272       {
81273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81274       };
81275     } catch (...) {
81276       {
81277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81278       };
81279     }
81280   }
81281
81282   jresult = result;
81283   return jresult;
81284 }
81285
81286
81287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
81288   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81289   Dali::Vector2 *arg2 = 0 ;
81290
81291   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81292   arg2 = (Dali::Vector2 *)jarg2;
81293   if (!arg2) {
81294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81295     return ;
81296   }
81297   {
81298     try {
81299       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
81300     } catch (std::out_of_range& e) {
81301       {
81302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81303       };
81304     } catch (std::exception& e) {
81305       {
81306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81307       };
81308     } catch (Dali::DaliException e) {
81309       {
81310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81311       };
81312     } catch (...) {
81313       {
81314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81315       };
81316     }
81317   }
81318
81319 }
81320
81321
81322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
81323   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81324   Dali::Vector2 *arg2 = 0 ;
81325   float arg3 ;
81326
81327   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81328   arg2 = (Dali::Vector2 *)jarg2;
81329   if (!arg2) {
81330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81331     return ;
81332   }
81333   arg3 = (float)jarg3;
81334   {
81335     try {
81336       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
81337     } catch (std::out_of_range& e) {
81338       {
81339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81340       };
81341     } catch (std::exception& e) {
81342       {
81343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81344       };
81345     } catch (Dali::DaliException e) {
81346       {
81347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81348       };
81349     } catch (...) {
81350       {
81351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81352       };
81353     }
81354   }
81355
81356 }
81357
81358
81359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
81360   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81361   Dali::Vector2 *arg2 = 0 ;
81362   float arg3 ;
81363   Dali::AlphaFunction arg4 ;
81364   Dali::AlphaFunction *argp4 ;
81365
81366   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81367   arg2 = (Dali::Vector2 *)jarg2;
81368   if (!arg2) {
81369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81370     return ;
81371   }
81372   arg3 = (float)jarg3;
81373   argp4 = (Dali::AlphaFunction *)jarg4;
81374   if (!argp4) {
81375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81376     return ;
81377   }
81378   arg4 = *argp4;
81379   {
81380     try {
81381       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
81382     } catch (std::out_of_range& e) {
81383       {
81384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81385       };
81386     } catch (std::exception& e) {
81387       {
81388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81389       };
81390     } catch (Dali::DaliException e) {
81391       {
81392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81393       };
81394     } catch (...) {
81395       {
81396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81397       };
81398     }
81399   }
81400
81401 }
81402
81403
81404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
81405   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81406   Dali::Vector2 *arg2 = 0 ;
81407   float arg3 ;
81408   Dali::Toolkit::DirectionBias arg4 ;
81409   Dali::Toolkit::DirectionBias arg5 ;
81410
81411   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81412   arg2 = (Dali::Vector2 *)jarg2;
81413   if (!arg2) {
81414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81415     return ;
81416   }
81417   arg3 = (float)jarg3;
81418   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81419   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81420   {
81421     try {
81422       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
81423     } catch (std::out_of_range& e) {
81424       {
81425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81426       };
81427     } catch (std::exception& e) {
81428       {
81429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81430       };
81431     } catch (Dali::DaliException e) {
81432       {
81433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81434       };
81435     } catch (...) {
81436       {
81437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81438       };
81439     }
81440   }
81441
81442 }
81443
81444
81445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
81446   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81447   Dali::Vector2 *arg2 = 0 ;
81448   float arg3 ;
81449   Dali::AlphaFunction arg4 ;
81450   Dali::Toolkit::DirectionBias arg5 ;
81451   Dali::Toolkit::DirectionBias arg6 ;
81452   Dali::AlphaFunction *argp4 ;
81453
81454   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81455   arg2 = (Dali::Vector2 *)jarg2;
81456   if (!arg2) {
81457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81458     return ;
81459   }
81460   arg3 = (float)jarg3;
81461   argp4 = (Dali::AlphaFunction *)jarg4;
81462   if (!argp4) {
81463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81464     return ;
81465   }
81466   arg4 = *argp4;
81467   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81468   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
81469   {
81470     try {
81471       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
81472     } catch (std::out_of_range& e) {
81473       {
81474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81475       };
81476     } catch (std::exception& e) {
81477       {
81478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81479       };
81480     } catch (Dali::DaliException e) {
81481       {
81482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81483       };
81484     } catch (...) {
81485       {
81486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81487       };
81488     }
81489   }
81490
81491 }
81492
81493
81494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
81495   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81496   unsigned int arg2 ;
81497
81498   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81499   arg2 = (unsigned int)jarg2;
81500   {
81501     try {
81502       (arg1)->ScrollTo(arg2);
81503     } catch (std::out_of_range& e) {
81504       {
81505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81506       };
81507     } catch (std::exception& e) {
81508       {
81509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81510       };
81511     } catch (Dali::DaliException e) {
81512       {
81513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81514       };
81515     } catch (...) {
81516       {
81517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81518       };
81519     }
81520   }
81521
81522 }
81523
81524
81525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
81526   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81527   unsigned int arg2 ;
81528   float arg3 ;
81529
81530   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81531   arg2 = (unsigned int)jarg2;
81532   arg3 = (float)jarg3;
81533   {
81534     try {
81535       (arg1)->ScrollTo(arg2,arg3);
81536     } catch (std::out_of_range& e) {
81537       {
81538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81539       };
81540     } catch (std::exception& e) {
81541       {
81542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81543       };
81544     } catch (Dali::DaliException e) {
81545       {
81546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81547       };
81548     } catch (...) {
81549       {
81550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81551       };
81552     }
81553   }
81554
81555 }
81556
81557
81558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
81559   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81560   unsigned int arg2 ;
81561   float arg3 ;
81562   Dali::Toolkit::DirectionBias arg4 ;
81563
81564   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81565   arg2 = (unsigned int)jarg2;
81566   arg3 = (float)jarg3;
81567   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81568   {
81569     try {
81570       (arg1)->ScrollTo(arg2,arg3,arg4);
81571     } catch (std::out_of_range& e) {
81572       {
81573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81574       };
81575     } catch (std::exception& e) {
81576       {
81577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81578       };
81579     } catch (Dali::DaliException e) {
81580       {
81581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81582       };
81583     } catch (...) {
81584       {
81585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81586       };
81587     }
81588   }
81589
81590 }
81591
81592
81593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
81594   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81595   Dali::Actor *arg2 = 0 ;
81596
81597   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81598   arg2 = (Dali::Actor *)jarg2;
81599   if (!arg2) {
81600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
81601     return ;
81602   }
81603   {
81604     try {
81605       (arg1)->ScrollTo(*arg2);
81606     } catch (std::out_of_range& e) {
81607       {
81608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81609       };
81610     } catch (std::exception& e) {
81611       {
81612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81613       };
81614     } catch (Dali::DaliException e) {
81615       {
81616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81617       };
81618     } catch (...) {
81619       {
81620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81621       };
81622     }
81623   }
81624
81625 }
81626
81627
81628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
81629   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81630   Dali::Actor *arg2 = 0 ;
81631   float arg3 ;
81632
81633   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81634   arg2 = (Dali::Actor *)jarg2;
81635   if (!arg2) {
81636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
81637     return ;
81638   }
81639   arg3 = (float)jarg3;
81640   {
81641     try {
81642       (arg1)->ScrollTo(*arg2,arg3);
81643     } catch (std::out_of_range& e) {
81644       {
81645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81646       };
81647     } catch (std::exception& e) {
81648       {
81649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81650       };
81651     } catch (Dali::DaliException e) {
81652       {
81653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81654       };
81655     } catch (...) {
81656       {
81657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81658       };
81659     }
81660   }
81661
81662 }
81663
81664
81665 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
81666   unsigned int jresult ;
81667   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81668   bool result;
81669
81670   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81671   {
81672     try {
81673       result = (bool)(arg1)->ScrollToSnapPoint();
81674     } catch (std::out_of_range& e) {
81675       {
81676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81677       };
81678     } catch (std::exception& e) {
81679       {
81680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81681       };
81682     } catch (Dali::DaliException e) {
81683       {
81684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81685       };
81686     } catch (...) {
81687       {
81688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81689       };
81690     }
81691   }
81692
81693   jresult = result;
81694   return jresult;
81695 }
81696
81697
81698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
81699   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81700   Dali::Constraint arg2 ;
81701   Dali::Constraint *argp2 ;
81702
81703   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81704   argp2 = (Dali::Constraint *)jarg2;
81705   if (!argp2) {
81706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
81707     return ;
81708   }
81709   arg2 = *argp2;
81710   {
81711     try {
81712       (arg1)->ApplyConstraintToChildren(arg2);
81713     } catch (std::out_of_range& e) {
81714       {
81715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81716       };
81717     } catch (std::exception& e) {
81718       {
81719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81720       };
81721     } catch (Dali::DaliException e) {
81722       {
81723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81724       };
81725     } catch (...) {
81726       {
81727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81728       };
81729     }
81730   }
81731
81732 }
81733
81734
81735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
81736   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81737
81738   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81739   {
81740     try {
81741       (arg1)->RemoveConstraintsFromChildren();
81742     } catch (std::out_of_range& e) {
81743       {
81744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81745       };
81746     } catch (std::exception& e) {
81747       {
81748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81749       };
81750     } catch (Dali::DaliException e) {
81751       {
81752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81753       };
81754     } catch (...) {
81755       {
81756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81757       };
81758     }
81759   }
81760
81761 }
81762
81763
81764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
81765   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81766   Dali::Toolkit::ScrollViewEffect arg2 ;
81767   Dali::Toolkit::ScrollViewEffect *argp2 ;
81768
81769   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81770   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
81771   if (!argp2) {
81772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
81773     return ;
81774   }
81775   arg2 = *argp2;
81776   {
81777     try {
81778       (arg1)->ApplyEffect(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_RemoveEffect(void * jarg1, void * jarg2) {
81802   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81803   Dali::Toolkit::ScrollViewEffect arg2 ;
81804   Dali::Toolkit::ScrollViewEffect *argp2 ;
81805
81806   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81807   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
81808   if (!argp2) {
81809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
81810     return ;
81811   }
81812   arg2 = *argp2;
81813   {
81814     try {
81815       (arg1)->RemoveEffect(arg2);
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_RemoveAllEffects(void * jarg1) {
81839   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81840
81841   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81842   {
81843     try {
81844       (arg1)->RemoveAllEffects();
81845     } catch (std::out_of_range& e) {
81846       {
81847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81848       };
81849     } catch (std::exception& e) {
81850       {
81851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81852       };
81853     } catch (Dali::DaliException e) {
81854       {
81855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81856       };
81857     } catch (...) {
81858       {
81859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81860       };
81861     }
81862   }
81863
81864 }
81865
81866
81867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
81868   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81869   Dali::Actor arg2 ;
81870   Dali::Actor *argp2 ;
81871
81872   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81873   argp2 = (Dali::Actor *)jarg2;
81874   if (!argp2) {
81875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81876     return ;
81877   }
81878   arg2 = *argp2;
81879   {
81880     try {
81881       (arg1)->BindActor(arg2);
81882     } catch (std::out_of_range& e) {
81883       {
81884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81885       };
81886     } catch (std::exception& e) {
81887       {
81888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81889       };
81890     } catch (Dali::DaliException e) {
81891       {
81892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81893       };
81894     } catch (...) {
81895       {
81896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81897       };
81898     }
81899   }
81900
81901 }
81902
81903
81904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
81905   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81906   Dali::Actor arg2 ;
81907   Dali::Actor *argp2 ;
81908
81909   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81910   argp2 = (Dali::Actor *)jarg2;
81911   if (!argp2) {
81912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81913     return ;
81914   }
81915   arg2 = *argp2;
81916   {
81917     try {
81918       (arg1)->UnbindActor(arg2);
81919     } catch (std::out_of_range& e) {
81920       {
81921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81922       };
81923     } catch (std::exception& e) {
81924       {
81925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81926       };
81927     } catch (Dali::DaliException e) {
81928       {
81929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81930       };
81931     } catch (...) {
81932       {
81933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81934       };
81935     }
81936   }
81937
81938 }
81939
81940
81941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
81942   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81943   Dali::Radian arg2 ;
81944   Dali::Radian arg3 ;
81945   Dali::Radian *argp2 ;
81946   Dali::Radian *argp3 ;
81947
81948   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81949   argp2 = (Dali::Radian *)jarg2;
81950   if (!argp2) {
81951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81952     return ;
81953   }
81954   arg2 = *argp2;
81955   argp3 = (Dali::Radian *)jarg3;
81956   if (!argp3) {
81957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81958     return ;
81959   }
81960   arg3 = *argp3;
81961   {
81962     try {
81963       (arg1)->SetScrollingDirection(arg2,arg3);
81964     } catch (std::out_of_range& e) {
81965       {
81966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81967       };
81968     } catch (std::exception& e) {
81969       {
81970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81971       };
81972     } catch (Dali::DaliException e) {
81973       {
81974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81975       };
81976     } catch (...) {
81977       {
81978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81979       };
81980     }
81981   }
81982
81983 }
81984
81985
81986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
81987   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81988   Dali::Radian arg2 ;
81989   Dali::Radian *argp2 ;
81990
81991   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81992   argp2 = (Dali::Radian *)jarg2;
81993   if (!argp2) {
81994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81995     return ;
81996   }
81997   arg2 = *argp2;
81998   {
81999     try {
82000       (arg1)->SetScrollingDirection(arg2);
82001     } catch (std::out_of_range& e) {
82002       {
82003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82004       };
82005     } catch (std::exception& e) {
82006       {
82007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82008       };
82009     } catch (Dali::DaliException e) {
82010       {
82011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82012       };
82013     } catch (...) {
82014       {
82015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82016       };
82017     }
82018   }
82019
82020 }
82021
82022
82023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
82024   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82025   Dali::Radian arg2 ;
82026   Dali::Radian *argp2 ;
82027
82028   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82029   argp2 = (Dali::Radian *)jarg2;
82030   if (!argp2) {
82031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82032     return ;
82033   }
82034   arg2 = *argp2;
82035   {
82036     try {
82037       (arg1)->RemoveScrollingDirection(arg2);
82038     } catch (std::out_of_range& e) {
82039       {
82040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82041       };
82042     } catch (std::exception& e) {
82043       {
82044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82045       };
82046     } catch (Dali::DaliException e) {
82047       {
82048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82049       };
82050     } catch (...) {
82051       {
82052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82053       };
82054     }
82055   }
82056
82057 }
82058
82059
82060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
82061   void * jresult ;
82062   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82063   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
82064
82065   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82066   {
82067     try {
82068       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
82069     } catch (std::out_of_range& e) {
82070       {
82071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82072       };
82073     } catch (std::exception& e) {
82074       {
82075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82076       };
82077     } catch (Dali::DaliException e) {
82078       {
82079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82080       };
82081     } catch (...) {
82082       {
82083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82084       };
82085     }
82086   }
82087
82088   jresult = (void *)result;
82089   return jresult;
82090 }
82091
82092
82093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
82094   int jresult ;
82095   int result;
82096
82097   result = (int)Dali::Toolkit::TableView::Property::ROWS;
82098   jresult = (int)result;
82099   return jresult;
82100 }
82101
82102
82103 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
82104   int jresult ;
82105   int result;
82106
82107   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
82108   jresult = (int)result;
82109   return jresult;
82110 }
82111
82112
82113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
82114   int jresult ;
82115   int result;
82116
82117   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
82118   jresult = (int)result;
82119   return jresult;
82120 }
82121
82122
82123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
82124   int jresult ;
82125   int result;
82126
82127   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
82128   jresult = (int)result;
82129   return jresult;
82130 }
82131
82132
82133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
82134   int jresult ;
82135   int result;
82136
82137   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
82138   jresult = (int)result;
82139   return jresult;
82140 }
82141
82142
82143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
82144   void * jresult ;
82145   Dali::Toolkit::TableView::Property *result = 0 ;
82146
82147   {
82148     try {
82149       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
82150     } catch (std::out_of_range& e) {
82151       {
82152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82153       };
82154     } catch (std::exception& e) {
82155       {
82156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82157       };
82158     } catch (Dali::DaliException e) {
82159       {
82160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82161       };
82162     } catch (...) {
82163       {
82164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82165       };
82166     }
82167   }
82168
82169   jresult = (void *)result;
82170   return jresult;
82171 }
82172
82173
82174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
82175   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
82176
82177   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
82178   {
82179     try {
82180       delete arg1;
82181     } catch (std::out_of_range& e) {
82182       {
82183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82184       };
82185     } catch (std::exception& e) {
82186       {
82187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82188       };
82189     } catch (Dali::DaliException e) {
82190       {
82191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82192       };
82193     } catch (...) {
82194       {
82195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82196       };
82197     }
82198   }
82199
82200 }
82201
82202
82203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
82204   int jresult ;
82205   int result;
82206
82207   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
82208   jresult = (int)result;
82209   return jresult;
82210 }
82211
82212
82213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
82214   int jresult ;
82215   int result;
82216
82217   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
82218   jresult = (int)result;
82219   return jresult;
82220 }
82221
82222
82223 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
82224   int jresult ;
82225   int result;
82226
82227   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
82228   jresult = (int)result;
82229   return jresult;
82230 }
82231
82232
82233 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
82234   int jresult ;
82235   int result;
82236
82237   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
82238   jresult = (int)result;
82239   return jresult;
82240 }
82241
82242
82243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
82244   int jresult ;
82245   int result;
82246
82247   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
82248   jresult = (int)result;
82249   return jresult;
82250 }
82251
82252
82253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
82254   void * jresult ;
82255   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
82256
82257   {
82258     try {
82259       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
82260     } catch (std::out_of_range& e) {
82261       {
82262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82263       };
82264     } catch (std::exception& e) {
82265       {
82266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82267       };
82268     } catch (Dali::DaliException e) {
82269       {
82270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82271       };
82272     } catch (...) {
82273       {
82274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82275       };
82276     }
82277   }
82278
82279   jresult = (void *)result;
82280   return jresult;
82281 }
82282
82283
82284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
82285   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
82286
82287   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
82288   {
82289     try {
82290       delete arg1;
82291     } catch (std::out_of_range& e) {
82292       {
82293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82294       };
82295     } catch (std::exception& e) {
82296       {
82297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82298       };
82299     } catch (Dali::DaliException e) {
82300       {
82301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82302       };
82303     } catch (...) {
82304       {
82305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82306       };
82307     }
82308   }
82309
82310 }
82311
82312
82313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
82314   void * jresult ;
82315   unsigned int arg1 ;
82316   unsigned int arg2 ;
82317   unsigned int arg3 ;
82318   unsigned int arg4 ;
82319   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82320
82321   arg1 = (unsigned int)jarg1;
82322   arg2 = (unsigned int)jarg2;
82323   arg3 = (unsigned int)jarg3;
82324   arg4 = (unsigned int)jarg4;
82325   {
82326     try {
82327       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
82328     } catch (std::out_of_range& e) {
82329       {
82330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82331       };
82332     } catch (std::exception& e) {
82333       {
82334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82335       };
82336     } catch (Dali::DaliException e) {
82337       {
82338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82339       };
82340     } catch (...) {
82341       {
82342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82343       };
82344     }
82345   }
82346
82347   jresult = (void *)result;
82348   return jresult;
82349 }
82350
82351
82352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
82353   void * jresult ;
82354   unsigned int arg1 ;
82355   unsigned int arg2 ;
82356   unsigned int arg3 ;
82357   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82358
82359   arg1 = (unsigned int)jarg1;
82360   arg2 = (unsigned int)jarg2;
82361   arg3 = (unsigned int)jarg3;
82362   {
82363     try {
82364       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
82365     } catch (std::out_of_range& e) {
82366       {
82367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82368       };
82369     } catch (std::exception& e) {
82370       {
82371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82372       };
82373     } catch (Dali::DaliException e) {
82374       {
82375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82376       };
82377     } catch (...) {
82378       {
82379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82380       };
82381     }
82382   }
82383
82384   jresult = (void *)result;
82385   return jresult;
82386 }
82387
82388
82389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
82390   void * jresult ;
82391   unsigned int arg1 ;
82392   unsigned int arg2 ;
82393   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82394
82395   arg1 = (unsigned int)jarg1;
82396   arg2 = (unsigned int)jarg2;
82397   {
82398     try {
82399       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
82400     } catch (std::out_of_range& e) {
82401       {
82402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82403       };
82404     } catch (std::exception& e) {
82405       {
82406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82407       };
82408     } catch (Dali::DaliException e) {
82409       {
82410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82411       };
82412     } catch (...) {
82413       {
82414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82415       };
82416     }
82417   }
82418
82419   jresult = (void *)result;
82420   return jresult;
82421 }
82422
82423
82424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
82425   void * jresult ;
82426   unsigned int arg1 ;
82427   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82428
82429   arg1 = (unsigned int)jarg1;
82430   {
82431     try {
82432       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
82433     } catch (std::out_of_range& e) {
82434       {
82435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82436       };
82437     } catch (std::exception& e) {
82438       {
82439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82440       };
82441     } catch (Dali::DaliException e) {
82442       {
82443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82444       };
82445     } catch (...) {
82446       {
82447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82448       };
82449     }
82450   }
82451
82452   jresult = (void *)result;
82453   return jresult;
82454 }
82455
82456
82457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
82458   void * jresult ;
82459   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82460
82461   {
82462     try {
82463       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
82464     } catch (std::out_of_range& e) {
82465       {
82466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82467       };
82468     } catch (std::exception& e) {
82469       {
82470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82471       };
82472     } catch (Dali::DaliException e) {
82473       {
82474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82475       };
82476     } catch (...) {
82477       {
82478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82479       };
82480     }
82481   }
82482
82483   jresult = (void *)result;
82484   return jresult;
82485 }
82486
82487
82488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
82489   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82490   unsigned int arg2 ;
82491
82492   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82493   arg2 = (unsigned int)jarg2;
82494   if (arg1) (arg1)->rowIndex = arg2;
82495 }
82496
82497
82498 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
82499   unsigned int jresult ;
82500   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82501   unsigned int result;
82502
82503   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82504   result = (unsigned int) ((arg1)->rowIndex);
82505   jresult = result;
82506   return jresult;
82507 }
82508
82509
82510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
82511   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82512   unsigned int arg2 ;
82513
82514   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82515   arg2 = (unsigned int)jarg2;
82516   if (arg1) (arg1)->columnIndex = arg2;
82517 }
82518
82519
82520 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
82521   unsigned int jresult ;
82522   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82523   unsigned int result;
82524
82525   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82526   result = (unsigned int) ((arg1)->columnIndex);
82527   jresult = result;
82528   return jresult;
82529 }
82530
82531
82532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
82533   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82534   unsigned int arg2 ;
82535
82536   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82537   arg2 = (unsigned int)jarg2;
82538   if (arg1) (arg1)->rowSpan = arg2;
82539 }
82540
82541
82542 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
82543   unsigned int jresult ;
82544   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82545   unsigned int result;
82546
82547   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82548   result = (unsigned int) ((arg1)->rowSpan);
82549   jresult = result;
82550   return jresult;
82551 }
82552
82553
82554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
82555   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82556   unsigned int arg2 ;
82557
82558   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82559   arg2 = (unsigned int)jarg2;
82560   if (arg1) (arg1)->columnSpan = arg2;
82561 }
82562
82563
82564 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
82565   unsigned int jresult ;
82566   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82567   unsigned int result;
82568
82569   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82570   result = (unsigned int) ((arg1)->columnSpan);
82571   jresult = result;
82572   return jresult;
82573 }
82574
82575
82576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
82577   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82578
82579   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82580   {
82581     try {
82582       delete arg1;
82583     } catch (std::out_of_range& e) {
82584       {
82585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82586       };
82587     } catch (std::exception& e) {
82588       {
82589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82590       };
82591     } catch (Dali::DaliException e) {
82592       {
82593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82594       };
82595     } catch (...) {
82596       {
82597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82598       };
82599     }
82600   }
82601
82602 }
82603
82604
82605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
82606   void * jresult ;
82607   Dali::Toolkit::TableView *result = 0 ;
82608
82609   {
82610     try {
82611       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
82612     } catch (std::out_of_range& e) {
82613       {
82614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82615       };
82616     } catch (std::exception& e) {
82617       {
82618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82619       };
82620     } catch (Dali::DaliException e) {
82621       {
82622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82623       };
82624     } catch (...) {
82625       {
82626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82627       };
82628     }
82629   }
82630
82631   jresult = (void *)result;
82632   return jresult;
82633 }
82634
82635
82636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
82637   void * jresult ;
82638   Dali::Toolkit::TableView *arg1 = 0 ;
82639   Dali::Toolkit::TableView *result = 0 ;
82640
82641   arg1 = (Dali::Toolkit::TableView *)jarg1;
82642   if (!arg1) {
82643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
82644     return 0;
82645   }
82646   {
82647     try {
82648       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
82649     } catch (std::out_of_range& e) {
82650       {
82651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82652       };
82653     } catch (std::exception& e) {
82654       {
82655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82656       };
82657     } catch (Dali::DaliException e) {
82658       {
82659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82660       };
82661     } catch (...) {
82662       {
82663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82664       };
82665     }
82666   }
82667
82668   jresult = (void *)result;
82669   return jresult;
82670 }
82671
82672
82673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
82674   void * jresult ;
82675   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82676   Dali::Toolkit::TableView *arg2 = 0 ;
82677   Dali::Toolkit::TableView *result = 0 ;
82678
82679   arg1 = (Dali::Toolkit::TableView *)jarg1;
82680   arg2 = (Dali::Toolkit::TableView *)jarg2;
82681   if (!arg2) {
82682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
82683     return 0;
82684   }
82685   {
82686     try {
82687       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
82688     } catch (std::out_of_range& e) {
82689       {
82690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82691       };
82692     } catch (std::exception& e) {
82693       {
82694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82695       };
82696     } catch (Dali::DaliException e) {
82697       {
82698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82699       };
82700     } catch (...) {
82701       {
82702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82703       };
82704     }
82705   }
82706
82707   jresult = (void *)result;
82708   return jresult;
82709 }
82710
82711
82712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
82713   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82714
82715   arg1 = (Dali::Toolkit::TableView *)jarg1;
82716   {
82717     try {
82718       delete arg1;
82719     } catch (std::out_of_range& e) {
82720       {
82721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82722       };
82723     } catch (std::exception& e) {
82724       {
82725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82726       };
82727     } catch (Dali::DaliException e) {
82728       {
82729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82730       };
82731     } catch (...) {
82732       {
82733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82734       };
82735     }
82736   }
82737
82738 }
82739
82740
82741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
82742   void * jresult ;
82743   unsigned int arg1 ;
82744   unsigned int arg2 ;
82745   Dali::Toolkit::TableView result;
82746
82747   arg1 = (unsigned int)jarg1;
82748   arg2 = (unsigned int)jarg2;
82749   {
82750     try {
82751       result = Dali::Toolkit::TableView::New(arg1,arg2);
82752     } catch (std::out_of_range& e) {
82753       {
82754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82755       };
82756     } catch (std::exception& e) {
82757       {
82758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82759       };
82760     } catch (Dali::DaliException e) {
82761       {
82762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82763       };
82764     } catch (...) {
82765       {
82766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82767       };
82768     }
82769   }
82770
82771   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
82772   return jresult;
82773 }
82774
82775
82776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
82777   void * jresult ;
82778   Dali::BaseHandle arg1 ;
82779   Dali::BaseHandle *argp1 ;
82780   Dali::Toolkit::TableView result;
82781
82782   argp1 = (Dali::BaseHandle *)jarg1;
82783   if (!argp1) {
82784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82785     return 0;
82786   }
82787   arg1 = *argp1;
82788   {
82789     try {
82790       result = Dali::Toolkit::TableView::DownCast(arg1);
82791     } catch (std::out_of_range& e) {
82792       {
82793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82794       };
82795     } catch (std::exception& e) {
82796       {
82797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82798       };
82799     } catch (Dali::DaliException e) {
82800       {
82801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82802       };
82803     } catch (...) {
82804       {
82805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82806       };
82807     }
82808   }
82809
82810   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
82811   return jresult;
82812 }
82813
82814
82815 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
82816   unsigned int jresult ;
82817   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82818   Dali::Actor arg2 ;
82819   Dali::Toolkit::TableView::CellPosition arg3 ;
82820   Dali::Actor *argp2 ;
82821   Dali::Toolkit::TableView::CellPosition *argp3 ;
82822   bool result;
82823
82824   arg1 = (Dali::Toolkit::TableView *)jarg1;
82825   argp2 = (Dali::Actor *)jarg2;
82826   if (!argp2) {
82827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82828     return 0;
82829   }
82830   arg2 = *argp2;
82831   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
82832   if (!argp3) {
82833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82834     return 0;
82835   }
82836   arg3 = *argp3;
82837   {
82838     try {
82839       result = (bool)(arg1)->AddChild(arg2,arg3);
82840     } catch (std::out_of_range& e) {
82841       {
82842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82843       };
82844     } catch (std::exception& e) {
82845       {
82846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82847       };
82848     } catch (Dali::DaliException e) {
82849       {
82850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82851       };
82852     } catch (...) {
82853       {
82854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82855       };
82856     }
82857   }
82858
82859   jresult = result;
82860   return jresult;
82861 }
82862
82863
82864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
82865   void * jresult ;
82866   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82867   Dali::Toolkit::TableView::CellPosition arg2 ;
82868   Dali::Toolkit::TableView::CellPosition *argp2 ;
82869   Dali::Actor result;
82870
82871   arg1 = (Dali::Toolkit::TableView *)jarg1;
82872   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
82873   if (!argp2) {
82874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82875     return 0;
82876   }
82877   arg2 = *argp2;
82878   {
82879     try {
82880       result = (arg1)->GetChildAt(arg2);
82881     } catch (std::out_of_range& e) {
82882       {
82883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82884       };
82885     } catch (std::exception& e) {
82886       {
82887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82888       };
82889     } catch (Dali::DaliException e) {
82890       {
82891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82892       };
82893     } catch (...) {
82894       {
82895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82896       };
82897     }
82898   }
82899
82900   jresult = new Dali::Actor((const Dali::Actor &)result);
82901   return jresult;
82902 }
82903
82904
82905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
82906   void * jresult ;
82907   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82908   Dali::Toolkit::TableView::CellPosition arg2 ;
82909   Dali::Toolkit::TableView::CellPosition *argp2 ;
82910   Dali::Actor result;
82911
82912   arg1 = (Dali::Toolkit::TableView *)jarg1;
82913   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
82914   if (!argp2) {
82915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82916     return 0;
82917   }
82918   arg2 = *argp2;
82919   {
82920     try {
82921       result = (arg1)->RemoveChildAt(arg2);
82922     } catch (std::out_of_range& e) {
82923       {
82924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82925       };
82926     } catch (std::exception& e) {
82927       {
82928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82929       };
82930     } catch (Dali::DaliException e) {
82931       {
82932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82933       };
82934     } catch (...) {
82935       {
82936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82937       };
82938     }
82939   }
82940
82941   jresult = new Dali::Actor((const Dali::Actor &)result);
82942   return jresult;
82943 }
82944
82945
82946 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
82947   unsigned int jresult ;
82948   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82949   Dali::Actor arg2 ;
82950   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
82951   Dali::Actor *argp2 ;
82952   bool result;
82953
82954   arg1 = (Dali::Toolkit::TableView *)jarg1;
82955   argp2 = (Dali::Actor *)jarg2;
82956   if (!argp2) {
82957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82958     return 0;
82959   }
82960   arg2 = *argp2;
82961   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
82962   if (!arg3) {
82963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
82964     return 0;
82965   }
82966   {
82967     try {
82968       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
82969     } catch (std::out_of_range& e) {
82970       {
82971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82972       };
82973     } catch (std::exception& e) {
82974       {
82975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82976       };
82977     } catch (Dali::DaliException e) {
82978       {
82979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82980       };
82981     } catch (...) {
82982       {
82983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82984       };
82985     }
82986   }
82987
82988   jresult = result;
82989   return jresult;
82990 }
82991
82992
82993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
82994   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82995   unsigned int arg2 ;
82996
82997   arg1 = (Dali::Toolkit::TableView *)jarg1;
82998   arg2 = (unsigned int)jarg2;
82999   {
83000     try {
83001       (arg1)->InsertRow(arg2);
83002     } catch (std::out_of_range& e) {
83003       {
83004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83005       };
83006     } catch (std::exception& e) {
83007       {
83008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83009       };
83010     } catch (Dali::DaliException e) {
83011       {
83012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83013       };
83014     } catch (...) {
83015       {
83016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83017       };
83018     }
83019   }
83020
83021 }
83022
83023
83024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
83025   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83026   unsigned int arg2 ;
83027
83028   arg1 = (Dali::Toolkit::TableView *)jarg1;
83029   arg2 = (unsigned int)jarg2;
83030   {
83031     try {
83032       (arg1)->DeleteRow(arg2);
83033     } catch (std::out_of_range& e) {
83034       {
83035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83036       };
83037     } catch (std::exception& e) {
83038       {
83039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83040       };
83041     } catch (Dali::DaliException e) {
83042       {
83043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83044       };
83045     } catch (...) {
83046       {
83047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83048       };
83049     }
83050   }
83051
83052 }
83053
83054
83055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
83056   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83057   unsigned int arg2 ;
83058   std::vector< Dali::Actor > *arg3 = 0 ;
83059
83060   arg1 = (Dali::Toolkit::TableView *)jarg1;
83061   arg2 = (unsigned int)jarg2;
83062   arg3 = (std::vector< Dali::Actor > *)jarg3;
83063   if (!arg3) {
83064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83065     return ;
83066   }
83067   {
83068     try {
83069       (arg1)->DeleteRow(arg2,*arg3);
83070     } catch (std::out_of_range& e) {
83071       {
83072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83073       };
83074     } catch (std::exception& e) {
83075       {
83076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83077       };
83078     } catch (Dali::DaliException e) {
83079       {
83080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83081       };
83082     } catch (...) {
83083       {
83084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83085       };
83086     }
83087   }
83088
83089 }
83090
83091
83092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
83093   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83094   unsigned int arg2 ;
83095
83096   arg1 = (Dali::Toolkit::TableView *)jarg1;
83097   arg2 = (unsigned int)jarg2;
83098   {
83099     try {
83100       (arg1)->InsertColumn(arg2);
83101     } catch (std::out_of_range& e) {
83102       {
83103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83104       };
83105     } catch (std::exception& e) {
83106       {
83107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83108       };
83109     } catch (Dali::DaliException e) {
83110       {
83111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83112       };
83113     } catch (...) {
83114       {
83115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83116       };
83117     }
83118   }
83119
83120 }
83121
83122
83123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
83124   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83125   unsigned int arg2 ;
83126
83127   arg1 = (Dali::Toolkit::TableView *)jarg1;
83128   arg2 = (unsigned int)jarg2;
83129   {
83130     try {
83131       (arg1)->DeleteColumn(arg2);
83132     } catch (std::out_of_range& e) {
83133       {
83134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83135       };
83136     } catch (std::exception& e) {
83137       {
83138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83139       };
83140     } catch (Dali::DaliException e) {
83141       {
83142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83143       };
83144     } catch (...) {
83145       {
83146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83147       };
83148     }
83149   }
83150
83151 }
83152
83153
83154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
83155   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83156   unsigned int arg2 ;
83157   std::vector< Dali::Actor > *arg3 = 0 ;
83158
83159   arg1 = (Dali::Toolkit::TableView *)jarg1;
83160   arg2 = (unsigned int)jarg2;
83161   arg3 = (std::vector< Dali::Actor > *)jarg3;
83162   if (!arg3) {
83163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83164     return ;
83165   }
83166   {
83167     try {
83168       (arg1)->DeleteColumn(arg2,*arg3);
83169     } catch (std::out_of_range& e) {
83170       {
83171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83172       };
83173     } catch (std::exception& e) {
83174       {
83175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83176       };
83177     } catch (Dali::DaliException e) {
83178       {
83179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83180       };
83181     } catch (...) {
83182       {
83183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83184       };
83185     }
83186   }
83187
83188 }
83189
83190
83191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
83192   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83193   unsigned int arg2 ;
83194   unsigned int arg3 ;
83195
83196   arg1 = (Dali::Toolkit::TableView *)jarg1;
83197   arg2 = (unsigned int)jarg2;
83198   arg3 = (unsigned int)jarg3;
83199   {
83200     try {
83201       (arg1)->Resize(arg2,arg3);
83202     } catch (std::out_of_range& e) {
83203       {
83204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83205       };
83206     } catch (std::exception& e) {
83207       {
83208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83209       };
83210     } catch (Dali::DaliException e) {
83211       {
83212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83213       };
83214     } catch (...) {
83215       {
83216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83217       };
83218     }
83219   }
83220
83221 }
83222
83223
83224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
83225   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83226   unsigned int arg2 ;
83227   unsigned int arg3 ;
83228   std::vector< Dali::Actor > *arg4 = 0 ;
83229
83230   arg1 = (Dali::Toolkit::TableView *)jarg1;
83231   arg2 = (unsigned int)jarg2;
83232   arg3 = (unsigned int)jarg3;
83233   arg4 = (std::vector< Dali::Actor > *)jarg4;
83234   if (!arg4) {
83235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83236     return ;
83237   }
83238   {
83239     try {
83240       (arg1)->Resize(arg2,arg3,*arg4);
83241     } catch (std::out_of_range& e) {
83242       {
83243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83244       };
83245     } catch (std::exception& e) {
83246       {
83247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83248       };
83249     } catch (Dali::DaliException e) {
83250       {
83251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83252       };
83253     } catch (...) {
83254       {
83255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83256       };
83257     }
83258   }
83259
83260 }
83261
83262
83263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
83264   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83265   Dali::Size arg2 ;
83266   Dali::Size *argp2 ;
83267
83268   arg1 = (Dali::Toolkit::TableView *)jarg1;
83269   argp2 = (Dali::Size *)jarg2;
83270   if (!argp2) {
83271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
83272     return ;
83273   }
83274   arg2 = *argp2;
83275   {
83276     try {
83277       (arg1)->SetCellPadding(arg2);
83278     } catch (std::out_of_range& e) {
83279       {
83280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83281       };
83282     } catch (std::exception& e) {
83283       {
83284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83285       };
83286     } catch (Dali::DaliException e) {
83287       {
83288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83289       };
83290     } catch (...) {
83291       {
83292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83293       };
83294     }
83295   }
83296
83297 }
83298
83299
83300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
83301   void * jresult ;
83302   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83303   Dali::Size result;
83304
83305   arg1 = (Dali::Toolkit::TableView *)jarg1;
83306   {
83307     try {
83308       result = (arg1)->GetCellPadding();
83309     } catch (std::out_of_range& e) {
83310       {
83311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83312       };
83313     } catch (std::exception& e) {
83314       {
83315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83316       };
83317     } catch (Dali::DaliException e) {
83318       {
83319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83320       };
83321     } catch (...) {
83322       {
83323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83324       };
83325     }
83326   }
83327
83328   jresult = new Dali::Size((const Dali::Size &)result);
83329   return jresult;
83330 }
83331
83332
83333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
83334   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83335   unsigned int arg2 ;
83336
83337   arg1 = (Dali::Toolkit::TableView *)jarg1;
83338   arg2 = (unsigned int)jarg2;
83339   {
83340     try {
83341       (arg1)->SetFitHeight(arg2);
83342     } catch (std::out_of_range& e) {
83343       {
83344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83345       };
83346     } catch (std::exception& e) {
83347       {
83348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83349       };
83350     } catch (Dali::DaliException e) {
83351       {
83352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83353       };
83354     } catch (...) {
83355       {
83356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83357       };
83358     }
83359   }
83360
83361 }
83362
83363
83364 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
83365   unsigned int jresult ;
83366   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83367   unsigned int arg2 ;
83368   bool result;
83369
83370   arg1 = (Dali::Toolkit::TableView *)jarg1;
83371   arg2 = (unsigned int)jarg2;
83372   {
83373     try {
83374       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
83375     } catch (std::out_of_range& e) {
83376       {
83377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83378       };
83379     } catch (std::exception& e) {
83380       {
83381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83382       };
83383     } catch (Dali::DaliException e) {
83384       {
83385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83386       };
83387     } catch (...) {
83388       {
83389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83390       };
83391     }
83392   }
83393
83394   jresult = result;
83395   return jresult;
83396 }
83397
83398
83399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
83400   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83401   unsigned int arg2 ;
83402
83403   arg1 = (Dali::Toolkit::TableView *)jarg1;
83404   arg2 = (unsigned int)jarg2;
83405   {
83406     try {
83407       (arg1)->SetFitWidth(arg2);
83408     } catch (std::out_of_range& e) {
83409       {
83410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83411       };
83412     } catch (std::exception& e) {
83413       {
83414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83415       };
83416     } catch (Dali::DaliException e) {
83417       {
83418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83419       };
83420     } catch (...) {
83421       {
83422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83423       };
83424     }
83425   }
83426
83427 }
83428
83429
83430 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
83431   unsigned int jresult ;
83432   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83433   unsigned int arg2 ;
83434   bool result;
83435
83436   arg1 = (Dali::Toolkit::TableView *)jarg1;
83437   arg2 = (unsigned int)jarg2;
83438   {
83439     try {
83440       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
83441     } catch (std::out_of_range& e) {
83442       {
83443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83444       };
83445     } catch (std::exception& e) {
83446       {
83447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83448       };
83449     } catch (Dali::DaliException e) {
83450       {
83451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83452       };
83453     } catch (...) {
83454       {
83455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83456       };
83457     }
83458   }
83459
83460   jresult = result;
83461   return jresult;
83462 }
83463
83464
83465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83466   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83467   unsigned int arg2 ;
83468   float arg3 ;
83469
83470   arg1 = (Dali::Toolkit::TableView *)jarg1;
83471   arg2 = (unsigned int)jarg2;
83472   arg3 = (float)jarg3;
83473   {
83474     try {
83475       (arg1)->SetFixedHeight(arg2,arg3);
83476     } catch (std::out_of_range& e) {
83477       {
83478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83479       };
83480     } catch (std::exception& e) {
83481       {
83482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83483       };
83484     } catch (Dali::DaliException e) {
83485       {
83486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83487       };
83488     } catch (...) {
83489       {
83490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83491       };
83492     }
83493   }
83494
83495 }
83496
83497
83498 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
83499   float jresult ;
83500   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83501   unsigned int arg2 ;
83502   float result;
83503
83504   arg1 = (Dali::Toolkit::TableView *)jarg1;
83505   arg2 = (unsigned int)jarg2;
83506   {
83507     try {
83508       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
83509     } catch (std::out_of_range& e) {
83510       {
83511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83512       };
83513     } catch (std::exception& e) {
83514       {
83515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83516       };
83517     } catch (Dali::DaliException e) {
83518       {
83519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83520       };
83521     } catch (...) {
83522       {
83523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83524       };
83525     }
83526   }
83527
83528   jresult = result;
83529   return jresult;
83530 }
83531
83532
83533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83534   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83535   unsigned int arg2 ;
83536   float arg3 ;
83537
83538   arg1 = (Dali::Toolkit::TableView *)jarg1;
83539   arg2 = (unsigned int)jarg2;
83540   arg3 = (float)jarg3;
83541   {
83542     try {
83543       (arg1)->SetRelativeHeight(arg2,arg3);
83544     } catch (std::out_of_range& e) {
83545       {
83546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83547       };
83548     } catch (std::exception& e) {
83549       {
83550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83551       };
83552     } catch (Dali::DaliException e) {
83553       {
83554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83555       };
83556     } catch (...) {
83557       {
83558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83559       };
83560     }
83561   }
83562
83563 }
83564
83565
83566 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
83567   float jresult ;
83568   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83569   unsigned int arg2 ;
83570   float result;
83571
83572   arg1 = (Dali::Toolkit::TableView *)jarg1;
83573   arg2 = (unsigned int)jarg2;
83574   {
83575     try {
83576       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
83577     } catch (std::out_of_range& e) {
83578       {
83579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83580       };
83581     } catch (std::exception& e) {
83582       {
83583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83584       };
83585     } catch (Dali::DaliException e) {
83586       {
83587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83588       };
83589     } catch (...) {
83590       {
83591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83592       };
83593     }
83594   }
83595
83596   jresult = result;
83597   return jresult;
83598 }
83599
83600
83601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
83602   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83603   unsigned int arg2 ;
83604   float arg3 ;
83605
83606   arg1 = (Dali::Toolkit::TableView *)jarg1;
83607   arg2 = (unsigned int)jarg2;
83608   arg3 = (float)jarg3;
83609   {
83610     try {
83611       (arg1)->SetFixedWidth(arg2,arg3);
83612     } catch (std::out_of_range& e) {
83613       {
83614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83615       };
83616     } catch (std::exception& e) {
83617       {
83618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83619       };
83620     } catch (Dali::DaliException e) {
83621       {
83622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83623       };
83624     } catch (...) {
83625       {
83626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83627       };
83628     }
83629   }
83630
83631 }
83632
83633
83634 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
83635   float jresult ;
83636   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83637   unsigned int arg2 ;
83638   float result;
83639
83640   arg1 = (Dali::Toolkit::TableView *)jarg1;
83641   arg2 = (unsigned int)jarg2;
83642   {
83643     try {
83644       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
83645     } catch (std::out_of_range& e) {
83646       {
83647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83648       };
83649     } catch (std::exception& e) {
83650       {
83651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83652       };
83653     } catch (Dali::DaliException e) {
83654       {
83655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83656       };
83657     } catch (...) {
83658       {
83659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83660       };
83661     }
83662   }
83663
83664   jresult = result;
83665   return jresult;
83666 }
83667
83668
83669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
83670   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83671   unsigned int arg2 ;
83672   float arg3 ;
83673
83674   arg1 = (Dali::Toolkit::TableView *)jarg1;
83675   arg2 = (unsigned int)jarg2;
83676   arg3 = (float)jarg3;
83677   {
83678     try {
83679       (arg1)->SetRelativeWidth(arg2,arg3);
83680     } catch (std::out_of_range& e) {
83681       {
83682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83683       };
83684     } catch (std::exception& e) {
83685       {
83686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83687       };
83688     } catch (Dali::DaliException e) {
83689       {
83690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83691       };
83692     } catch (...) {
83693       {
83694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83695       };
83696     }
83697   }
83698
83699 }
83700
83701
83702 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
83703   float jresult ;
83704   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83705   unsigned int arg2 ;
83706   float result;
83707
83708   arg1 = (Dali::Toolkit::TableView *)jarg1;
83709   arg2 = (unsigned int)jarg2;
83710   {
83711     try {
83712       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
83713     } catch (std::out_of_range& e) {
83714       {
83715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83716       };
83717     } catch (std::exception& e) {
83718       {
83719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83720       };
83721     } catch (Dali::DaliException e) {
83722       {
83723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83724       };
83725     } catch (...) {
83726       {
83727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83728       };
83729     }
83730   }
83731
83732   jresult = result;
83733   return jresult;
83734 }
83735
83736
83737 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
83738   unsigned int jresult ;
83739   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83740   unsigned int result;
83741
83742   arg1 = (Dali::Toolkit::TableView *)jarg1;
83743   {
83744     try {
83745       result = (unsigned int)(arg1)->GetRows();
83746     } catch (std::out_of_range& e) {
83747       {
83748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83749       };
83750     } catch (std::exception& e) {
83751       {
83752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83753       };
83754     } catch (Dali::DaliException e) {
83755       {
83756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83757       };
83758     } catch (...) {
83759       {
83760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83761       };
83762     }
83763   }
83764
83765   jresult = result;
83766   return jresult;
83767 }
83768
83769
83770 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
83771   unsigned int jresult ;
83772   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83773   unsigned int result;
83774
83775   arg1 = (Dali::Toolkit::TableView *)jarg1;
83776   {
83777     try {
83778       result = (unsigned int)(arg1)->GetColumns();
83779     } catch (std::out_of_range& e) {
83780       {
83781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83782       };
83783     } catch (std::exception& e) {
83784       {
83785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83786       };
83787     } catch (Dali::DaliException e) {
83788       {
83789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83790       };
83791     } catch (...) {
83792       {
83793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83794       };
83795     }
83796   }
83797
83798   jresult = result;
83799   return jresult;
83800 }
83801
83802
83803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
83804   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83805   Dali::Toolkit::TableView::CellPosition arg2 ;
83806   Dali::HorizontalAlignment::Type arg3 ;
83807   Dali::VerticalAlignment::Type arg4 ;
83808   Dali::Toolkit::TableView::CellPosition *argp2 ;
83809
83810   arg1 = (Dali::Toolkit::TableView *)jarg1;
83811   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
83812   if (!argp2) {
83813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83814     return ;
83815   }
83816   arg2 = *argp2;
83817   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
83818   arg4 = (Dali::VerticalAlignment::Type)jarg4;
83819   {
83820     try {
83821       (arg1)->SetCellAlignment(arg2,arg3,arg4);
83822     } catch (std::out_of_range& e) {
83823       {
83824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83825       };
83826     } catch (std::exception& e) {
83827       {
83828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83829       };
83830     } catch (Dali::DaliException e) {
83831       {
83832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83833       };
83834     } catch (...) {
83835       {
83836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83837       };
83838     }
83839   }
83840
83841 }
83842
83843
83844 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
83845   unsigned int jresult ;
83846   unsigned int result;
83847
83848   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
83849   jresult = result;
83850   return jresult;
83851 }
83852
83853
83854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
83855   int jresult ;
83856   int result;
83857
83858   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
83859   jresult = (int)result;
83860   return jresult;
83861 }
83862
83863
83864 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
83865   int jresult ;
83866   int result;
83867
83868   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
83869   jresult = (int)result;
83870   return jresult;
83871 }
83872
83873
83874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
83875   int jresult ;
83876   int result;
83877
83878   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
83879   jresult = (int)result;
83880   return jresult;
83881 }
83882
83883
83884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
83885   int jresult ;
83886   int result;
83887
83888   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
83889   jresult = (int)result;
83890   return jresult;
83891 }
83892
83893
83894 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
83895   int jresult ;
83896   int result;
83897
83898   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
83899   jresult = (int)result;
83900   return jresult;
83901 }
83902
83903
83904 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
83905   int jresult ;
83906   int result;
83907
83908   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
83909   jresult = (int)result;
83910   return jresult;
83911 }
83912
83913
83914 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
83915   int jresult ;
83916   int result;
83917
83918   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
83919   jresult = (int)result;
83920   return jresult;
83921 }
83922
83923
83924 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
83925   int jresult ;
83926   int result;
83927
83928   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
83929   jresult = (int)result;
83930   return jresult;
83931 }
83932
83933
83934 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
83935   int jresult ;
83936   int result;
83937
83938   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
83939   jresult = (int)result;
83940   return jresult;
83941 }
83942
83943 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
83944   int jresult ;
83945   int result;
83946
83947   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
83948   jresult = (int)result;
83949   return jresult;
83950 }
83951
83952
83953 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
83954   int jresult ;
83955   int result;
83956
83957   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
83958   jresult = (int)result;
83959   return jresult;
83960 }
83961
83962
83963 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
83964   int jresult ;
83965   int result;
83966
83967   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
83968   jresult = (int)result;
83969   return jresult;
83970 }
83971
83972
83973 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
83974   int jresult ;
83975   int result;
83976
83977   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
83978   jresult = (int)result;
83979   return jresult;
83980 }
83981
83982
83983 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
83984   int jresult ;
83985   int result;
83986
83987   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
83988   jresult = (int)result;
83989   return jresult;
83990 }
83991
83992
83993 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
83994   int jresult ;
83995   int result;
83996
83997   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
83998   jresult = (int)result;
83999   return jresult;
84000 }
84001
84002
84003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
84004   int jresult ;
84005   int result;
84006
84007   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
84008   jresult = (int)result;
84009   return jresult;
84010 }
84011
84012
84013 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
84014   int jresult ;
84015   int result;
84016
84017   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
84018   jresult = (int)result;
84019   return jresult;
84020 }
84021
84022
84023 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
84024   int jresult ;
84025   int result;
84026
84027   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
84028   jresult = (int)result;
84029   return jresult;
84030 }
84031
84032
84033 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
84034   int jresult ;
84035   int result;
84036
84037   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
84038   jresult = (int)result;
84039   return jresult;
84040 }
84041
84042
84043 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
84044   int jresult ;
84045   int result;
84046
84047   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
84048   jresult = (int)result;
84049   return jresult;
84050 }
84051
84052
84053 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
84054   int jresult ;
84055   int result;
84056
84057   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
84058   jresult = (int)result;
84059   return jresult;
84060 }
84061
84062
84063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
84064   int jresult ;
84065   int result;
84066
84067   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
84068   jresult = (int)result;
84069   return jresult;
84070 }
84071
84072
84073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
84074   int jresult ;
84075   int result;
84076
84077   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
84078   jresult = (int)result;
84079   return jresult;
84080 }
84081
84082
84083 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
84084   int jresult ;
84085   int result;
84086
84087   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
84088   jresult = (int)result;
84089   return jresult;
84090 }
84091
84092
84093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
84094   void * jresult ;
84095   Dali::Toolkit::TextLabel::Property *result = 0 ;
84096
84097   {
84098     try {
84099       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
84100     } catch (std::out_of_range& e) {
84101       {
84102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84103       };
84104     } catch (std::exception& e) {
84105       {
84106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84107       };
84108     } catch (Dali::DaliException e) {
84109       {
84110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84111       };
84112     } catch (...) {
84113       {
84114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84115       };
84116     }
84117   }
84118
84119   jresult = (void *)result;
84120   return jresult;
84121 }
84122
84123
84124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
84125   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
84126
84127   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
84128   {
84129     try {
84130       delete arg1;
84131     } catch (std::out_of_range& e) {
84132       {
84133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84134       };
84135     } catch (std::exception& e) {
84136       {
84137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84138       };
84139     } catch (Dali::DaliException e) {
84140       {
84141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84142       };
84143     } catch (...) {
84144       {
84145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84146       };
84147     }
84148   }
84149
84150 }
84151
84152
84153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
84154   void * jresult ;
84155   Dali::Toolkit::TextLabel result;
84156
84157   {
84158     try {
84159       result = Dali::Toolkit::TextLabel::New();
84160
84161       // default behaviour of NUI TextLabel
84162       result.SetProperty( Dali::Toolkit::DevelTextLabel::Property::VERTICAL_LINE_ALIGNMENT, Dali::Toolkit::DevelText::VerticalLineAlignment::MIDDLE );
84163     } catch (std::out_of_range& e) {
84164       {
84165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84166       };
84167     } catch (std::exception& e) {
84168       {
84169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84170       };
84171     } catch (Dali::DaliException e) {
84172       {
84173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84174       };
84175     } catch (...) {
84176       {
84177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84178       };
84179     }
84180   }
84181
84182   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84183   return jresult;
84184 }
84185
84186
84187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
84188   void * jresult ;
84189   std::string *arg1 = 0 ;
84190   Dali::Toolkit::TextLabel result;
84191
84192   if (!jarg1) {
84193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84194     return 0;
84195   }
84196   std::string arg1_str(jarg1);
84197   arg1 = &arg1_str;
84198   {
84199     try {
84200       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
84201
84202       // default behaviour of NUI TextLabel
84203       result.SetProperty( Dali::Toolkit::DevelTextLabel::Property::VERTICAL_LINE_ALIGNMENT, Dali::Toolkit::DevelText::VerticalLineAlignment::MIDDLE );
84204     } catch (std::out_of_range& e) {
84205       {
84206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84207       };
84208     } catch (std::exception& e) {
84209       {
84210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84211       };
84212     } catch (Dali::DaliException e) {
84213       {
84214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84215       };
84216     } catch (...) {
84217       {
84218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84219       };
84220     }
84221   }
84222
84223   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84224
84225   //argout typemap for const std::string&
84226
84227   return jresult;
84228 }
84229
84230
84231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
84232   void * jresult ;
84233   Dali::Toolkit::TextLabel *result = 0 ;
84234
84235   {
84236     try {
84237       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
84238     } catch (std::out_of_range& e) {
84239       {
84240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84241       };
84242     } catch (std::exception& e) {
84243       {
84244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84245       };
84246     } catch (Dali::DaliException e) {
84247       {
84248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84249       };
84250     } catch (...) {
84251       {
84252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84253       };
84254     }
84255   }
84256
84257   jresult = (void *)result;
84258   return jresult;
84259 }
84260
84261
84262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
84263   void * jresult ;
84264   Dali::Toolkit::TextLabel *arg1 = 0 ;
84265   Dali::Toolkit::TextLabel *result = 0 ;
84266
84267   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84268   if (!arg1) {
84269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84270     return 0;
84271   }
84272   {
84273     try {
84274       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
84275     } catch (std::out_of_range& e) {
84276       {
84277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84278       };
84279     } catch (std::exception& e) {
84280       {
84281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84282       };
84283     } catch (Dali::DaliException e) {
84284       {
84285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84286       };
84287     } catch (...) {
84288       {
84289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84290       };
84291     }
84292   }
84293
84294   jresult = (void *)result;
84295   return jresult;
84296 }
84297
84298
84299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
84300   void * jresult ;
84301   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84302   Dali::Toolkit::TextLabel *arg2 = 0 ;
84303   Dali::Toolkit::TextLabel *result = 0 ;
84304
84305   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84306   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
84307   if (!arg2) {
84308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84309     return 0;
84310   }
84311   {
84312     try {
84313       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
84314     } catch (std::out_of_range& e) {
84315       {
84316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84317       };
84318     } catch (std::exception& e) {
84319       {
84320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84321       };
84322     } catch (Dali::DaliException e) {
84323       {
84324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84325       };
84326     } catch (...) {
84327       {
84328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84329       };
84330     }
84331   }
84332
84333   jresult = (void *)result;
84334   return jresult;
84335 }
84336
84337
84338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
84339   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84340
84341   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84342   {
84343     try {
84344       delete arg1;
84345     } catch (std::out_of_range& e) {
84346       {
84347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84348       };
84349     } catch (std::exception& e) {
84350       {
84351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84352       };
84353     } catch (Dali::DaliException e) {
84354       {
84355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84356       };
84357     } catch (...) {
84358       {
84359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84360       };
84361     }
84362   }
84363
84364 }
84365
84366
84367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
84368   void * jresult ;
84369   Dali::BaseHandle arg1 ;
84370   Dali::BaseHandle *argp1 ;
84371   Dali::Toolkit::TextLabel result;
84372
84373   argp1 = (Dali::BaseHandle *)jarg1;
84374   if (!argp1) {
84375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84376     return 0;
84377   }
84378   arg1 = *argp1;
84379   {
84380     try {
84381       result = Dali::Toolkit::TextLabel::DownCast(arg1);
84382     } catch (std::out_of_range& e) {
84383       {
84384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84385       };
84386     } catch (std::exception& e) {
84387       {
84388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84389       };
84390     } catch (Dali::DaliException e) {
84391       {
84392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84393       };
84394     } catch (...) {
84395       {
84396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84397       };
84398     }
84399   }
84400
84401   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84402   return jresult;
84403 }
84404
84405
84406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
84407   void * jresult ;
84408   Dali::Toolkit::AccessibilityManager *result = 0 ;
84409
84410   {
84411     try {
84412       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
84413     } catch (std::out_of_range& e) {
84414       {
84415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84416       };
84417     } catch (std::exception& e) {
84418       {
84419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84420       };
84421     } catch (Dali::DaliException e) {
84422       {
84423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84424       };
84425     } catch (...) {
84426       {
84427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84428       };
84429     }
84430   }
84431
84432   jresult = (void *)result;
84433   return jresult;
84434 }
84435
84436
84437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
84438   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84439
84440   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84441   {
84442     try {
84443       delete arg1;
84444     } catch (std::out_of_range& e) {
84445       {
84446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84447       };
84448     } catch (std::exception& e) {
84449       {
84450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84451       };
84452     } catch (Dali::DaliException e) {
84453       {
84454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84455       };
84456     } catch (...) {
84457       {
84458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84459       };
84460     }
84461   }
84462
84463 }
84464
84465
84466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
84467   void * jresult ;
84468   Dali::Toolkit::AccessibilityManager result;
84469
84470   {
84471     try {
84472       result = Dali::Toolkit::AccessibilityManager::Get();
84473     } catch (std::out_of_range& e) {
84474       {
84475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84476       };
84477     } catch (std::exception& e) {
84478       {
84479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84480       };
84481     } catch (Dali::DaliException e) {
84482       {
84483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84484       };
84485     } catch (...) {
84486       {
84487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84488       };
84489     }
84490   }
84491
84492   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
84493   return jresult;
84494 }
84495
84496
84497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
84498   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84499   Dali::Actor arg2 ;
84500   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84501   std::string *arg4 = 0 ;
84502   Dali::Actor *argp2 ;
84503
84504   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84505   argp2 = (Dali::Actor *)jarg2;
84506   if (!argp2) {
84507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84508     return ;
84509   }
84510   arg2 = *argp2;
84511   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84512   if (!jarg4) {
84513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84514     return ;
84515   }
84516   std::string arg4_str(jarg4);
84517   arg4 = &arg4_str;
84518   {
84519     try {
84520       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
84521     } catch (std::out_of_range& e) {
84522       {
84523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84524       };
84525     } catch (std::exception& e) {
84526       {
84527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84528       };
84529     } catch (Dali::DaliException e) {
84530       {
84531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84532       };
84533     } catch (...) {
84534       {
84535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84536       };
84537     }
84538   }
84539
84540
84541   //argout typemap for const std::string&
84542
84543 }
84544
84545
84546 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
84547   char * jresult ;
84548   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84549   Dali::Actor arg2 ;
84550   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84551   Dali::Actor *argp2 ;
84552   std::string result;
84553
84554   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84555   argp2 = (Dali::Actor *)jarg2;
84556   if (!argp2) {
84557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84558     return 0;
84559   }
84560   arg2 = *argp2;
84561   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84562   {
84563     try {
84564       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
84565     } catch (std::out_of_range& e) {
84566       {
84567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84568       };
84569     } catch (std::exception& e) {
84570       {
84571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84572       };
84573     } catch (Dali::DaliException e) {
84574       {
84575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84576       };
84577     } catch (...) {
84578       {
84579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84580       };
84581     }
84582   }
84583
84584   jresult = SWIG_csharp_string_callback((&result)->c_str());
84585   return jresult;
84586 }
84587
84588
84589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
84590   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84591   Dali::Actor arg2 ;
84592   unsigned int arg3 ;
84593   Dali::Actor *argp2 ;
84594
84595   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84596   argp2 = (Dali::Actor *)jarg2;
84597   if (!argp2) {
84598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84599     return ;
84600   }
84601   arg2 = *argp2;
84602   arg3 = (unsigned int)jarg3;
84603   {
84604     try {
84605       (arg1)->SetFocusOrder(arg2,arg3);
84606     } catch (std::out_of_range& e) {
84607       {
84608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84609       };
84610     } catch (std::exception& e) {
84611       {
84612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84613       };
84614     } catch (Dali::DaliException e) {
84615       {
84616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84617       };
84618     } catch (...) {
84619       {
84620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84621       };
84622     }
84623   }
84624
84625 }
84626
84627
84628 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
84629   unsigned int jresult ;
84630   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84631   Dali::Actor arg2 ;
84632   Dali::Actor *argp2 ;
84633   unsigned int result;
84634
84635   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84636   argp2 = (Dali::Actor *)jarg2;
84637   if (!argp2) {
84638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84639     return 0;
84640   }
84641   arg2 = *argp2;
84642   {
84643     try {
84644       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
84645     } catch (std::out_of_range& e) {
84646       {
84647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84648       };
84649     } catch (std::exception& e) {
84650       {
84651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84652       };
84653     } catch (Dali::DaliException e) {
84654       {
84655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84656       };
84657     } catch (...) {
84658       {
84659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84660       };
84661     }
84662   }
84663
84664   jresult = result;
84665   return jresult;
84666 }
84667
84668
84669 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
84670   unsigned int jresult ;
84671   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84672   unsigned int result;
84673
84674   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84675   {
84676     try {
84677       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
84678     } catch (std::out_of_range& e) {
84679       {
84680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84681       };
84682     } catch (std::exception& e) {
84683       {
84684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84685       };
84686     } catch (Dali::DaliException e) {
84687       {
84688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84689       };
84690     } catch (...) {
84691       {
84692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84693       };
84694     }
84695   }
84696
84697   jresult = result;
84698   return jresult;
84699 }
84700
84701
84702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
84703   void * jresult ;
84704   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84705   unsigned int arg2 ;
84706   Dali::Actor result;
84707
84708   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84709   arg2 = (unsigned int)jarg2;
84710   {
84711     try {
84712       result = (arg1)->GetActorByFocusOrder(arg2);
84713     } catch (std::out_of_range& e) {
84714       {
84715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84716       };
84717     } catch (std::exception& e) {
84718       {
84719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84720       };
84721     } catch (Dali::DaliException e) {
84722       {
84723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84724       };
84725     } catch (...) {
84726       {
84727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84728       };
84729     }
84730   }
84731
84732   jresult = new Dali::Actor((const Dali::Actor &)result);
84733   return jresult;
84734 }
84735
84736
84737 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
84738   unsigned int jresult ;
84739   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84740   Dali::Actor arg2 ;
84741   Dali::Actor *argp2 ;
84742   bool result;
84743
84744   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84745   argp2 = (Dali::Actor *)jarg2;
84746   if (!argp2) {
84747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84748     return 0;
84749   }
84750   arg2 = *argp2;
84751   {
84752     try {
84753       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
84754     } catch (std::out_of_range& e) {
84755       {
84756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84757       };
84758     } catch (std::exception& e) {
84759       {
84760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84761       };
84762     } catch (Dali::DaliException e) {
84763       {
84764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84765       };
84766     } catch (...) {
84767       {
84768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84769       };
84770     }
84771   }
84772
84773   jresult = result;
84774   return jresult;
84775 }
84776
84777
84778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
84779   void * jresult ;
84780   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84781   Dali::Actor result;
84782
84783   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84784   {
84785     try {
84786       result = (arg1)->GetCurrentFocusActor();
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 = new Dali::Actor((const Dali::Actor &)result);
84807   return jresult;
84808 }
84809
84810
84811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
84812   void * jresult ;
84813   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84814   Dali::Actor result;
84815
84816   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84817   {
84818     try {
84819       result = (arg1)->GetCurrentFocusGroup();
84820     } catch (std::out_of_range& e) {
84821       {
84822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84823       };
84824     } catch (std::exception& e) {
84825       {
84826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84827       };
84828     } catch (Dali::DaliException e) {
84829       {
84830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84831       };
84832     } catch (...) {
84833       {
84834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84835       };
84836     }
84837   }
84838
84839   jresult = new Dali::Actor((const Dali::Actor &)result);
84840   return jresult;
84841 }
84842
84843
84844 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
84845   unsigned int jresult ;
84846   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84847   unsigned int result;
84848
84849   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84850   {
84851     try {
84852       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
84853     } catch (std::out_of_range& e) {
84854       {
84855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84856       };
84857     } catch (std::exception& e) {
84858       {
84859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84860       };
84861     } catch (Dali::DaliException e) {
84862       {
84863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84864       };
84865     } catch (...) {
84866       {
84867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84868       };
84869     }
84870   }
84871
84872   jresult = result;
84873   return jresult;
84874 }
84875
84876
84877 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
84878   unsigned int jresult ;
84879   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84880   bool result;
84881
84882   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84883   {
84884     try {
84885       result = (bool)(arg1)->MoveFocusForward();
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 = result;
84906   return jresult;
84907 }
84908
84909
84910 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
84911   unsigned int jresult ;
84912   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84913   bool result;
84914
84915   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84916   {
84917     try {
84918       result = (bool)(arg1)->MoveFocusBackward();
84919     } catch (std::out_of_range& e) {
84920       {
84921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84922       };
84923     } catch (std::exception& e) {
84924       {
84925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84926       };
84927     } catch (Dali::DaliException e) {
84928       {
84929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84930       };
84931     } catch (...) {
84932       {
84933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84934       };
84935     }
84936   }
84937
84938   jresult = result;
84939   return jresult;
84940 }
84941
84942
84943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
84944   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84945
84946   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84947   {
84948     try {
84949       (arg1)->ClearFocus();
84950     } catch (std::out_of_range& e) {
84951       {
84952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84953       };
84954     } catch (std::exception& e) {
84955       {
84956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84957       };
84958     } catch (Dali::DaliException e) {
84959       {
84960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84961       };
84962     } catch (...) {
84963       {
84964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84965       };
84966     }
84967   }
84968
84969 }
84970
84971
84972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
84973   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84974
84975   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84976   {
84977     try {
84978       (arg1)->Reset();
84979     } catch (std::out_of_range& e) {
84980       {
84981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84982       };
84983     } catch (std::exception& e) {
84984       {
84985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84986       };
84987     } catch (Dali::DaliException e) {
84988       {
84989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84990       };
84991     } catch (...) {
84992       {
84993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84994       };
84995     }
84996   }
84997
84998 }
84999
85000
85001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
85002   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85003   Dali::Actor arg2 ;
85004   bool arg3 ;
85005   Dali::Actor *argp2 ;
85006
85007   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85008   argp2 = (Dali::Actor *)jarg2;
85009   if (!argp2) {
85010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85011     return ;
85012   }
85013   arg2 = *argp2;
85014   arg3 = jarg3 ? true : false;
85015   {
85016     try {
85017       (arg1)->SetFocusGroup(arg2,arg3);
85018     } catch (std::out_of_range& e) {
85019       {
85020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85021       };
85022     } catch (std::exception& e) {
85023       {
85024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85025       };
85026     } catch (Dali::DaliException e) {
85027       {
85028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85029       };
85030     } catch (...) {
85031       {
85032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85033       };
85034     }
85035   }
85036
85037 }
85038
85039
85040 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
85041   unsigned int jresult ;
85042   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85043   Dali::Actor arg2 ;
85044   Dali::Actor *argp2 ;
85045   bool result;
85046
85047   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85048   argp2 = (Dali::Actor *)jarg2;
85049   if (!argp2) {
85050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85051     return 0;
85052   }
85053   arg2 = *argp2;
85054   {
85055     try {
85056       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
85057     } catch (std::out_of_range& e) {
85058       {
85059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85060       };
85061     } catch (std::exception& e) {
85062       {
85063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85064       };
85065     } catch (Dali::DaliException e) {
85066       {
85067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85068       };
85069     } catch (...) {
85070       {
85071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85072       };
85073     }
85074   }
85075
85076   jresult = result;
85077   return jresult;
85078 }
85079
85080
85081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
85082   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85083   bool arg2 ;
85084
85085   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85086   arg2 = jarg2 ? true : false;
85087   {
85088     try {
85089       (arg1)->SetGroupMode(arg2);
85090     } catch (std::out_of_range& e) {
85091       {
85092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85093       };
85094     } catch (std::exception& e) {
85095       {
85096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85097       };
85098     } catch (Dali::DaliException e) {
85099       {
85100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85101       };
85102     } catch (...) {
85103       {
85104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85105       };
85106     }
85107   }
85108
85109 }
85110
85111
85112 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
85113   unsigned int jresult ;
85114   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85115   bool result;
85116
85117   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85118   {
85119     try {
85120       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
85121     } catch (std::out_of_range& e) {
85122       {
85123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85124       };
85125     } catch (std::exception& e) {
85126       {
85127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85128       };
85129     } catch (Dali::DaliException e) {
85130       {
85131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85132       };
85133     } catch (...) {
85134       {
85135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85136       };
85137     }
85138   }
85139
85140   jresult = result;
85141   return jresult;
85142 }
85143
85144
85145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
85146   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85147   bool arg2 ;
85148
85149   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85150   arg2 = jarg2 ? true : false;
85151   {
85152     try {
85153       (arg1)->SetWrapMode(arg2);
85154     } catch (std::out_of_range& e) {
85155       {
85156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85157       };
85158     } catch (std::exception& e) {
85159       {
85160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85161       };
85162     } catch (Dali::DaliException e) {
85163       {
85164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85165       };
85166     } catch (...) {
85167       {
85168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85169       };
85170     }
85171   }
85172
85173 }
85174
85175
85176 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
85177   unsigned int jresult ;
85178   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85179   bool result;
85180
85181   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85182   {
85183     try {
85184       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
85185     } catch (std::out_of_range& e) {
85186       {
85187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85188       };
85189     } catch (std::exception& e) {
85190       {
85191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85192       };
85193     } catch (Dali::DaliException e) {
85194       {
85195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85196       };
85197     } catch (...) {
85198       {
85199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85200       };
85201     }
85202   }
85203
85204   jresult = result;
85205   return jresult;
85206 }
85207
85208
85209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
85210   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85211   Dali::Actor arg2 ;
85212   Dali::Actor *argp2 ;
85213
85214   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85215   argp2 = (Dali::Actor *)jarg2;
85216   if (!argp2) {
85217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85218     return ;
85219   }
85220   arg2 = *argp2;
85221   {
85222     try {
85223       (arg1)->SetFocusIndicatorActor(arg2);
85224     } catch (std::out_of_range& e) {
85225       {
85226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85227       };
85228     } catch (std::exception& e) {
85229       {
85230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85231       };
85232     } catch (Dali::DaliException e) {
85233       {
85234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85235       };
85236     } catch (...) {
85237       {
85238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85239       };
85240     }
85241   }
85242
85243 }
85244
85245
85246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
85247   void * jresult ;
85248   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85249   Dali::Actor result;
85250
85251   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85252   {
85253     try {
85254       result = (arg1)->GetFocusIndicatorActor();
85255     } catch (std::out_of_range& e) {
85256       {
85257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85258       };
85259     } catch (std::exception& e) {
85260       {
85261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85262       };
85263     } catch (Dali::DaliException e) {
85264       {
85265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85266       };
85267     } catch (...) {
85268       {
85269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85270       };
85271     }
85272   }
85273
85274   jresult = new Dali::Actor((const Dali::Actor &)result);
85275   return jresult;
85276 }
85277
85278
85279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
85280   void * jresult ;
85281   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85282   Dali::Actor arg2 ;
85283   Dali::Actor *argp2 ;
85284   Dali::Actor result;
85285
85286   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85287   argp2 = (Dali::Actor *)jarg2;
85288   if (!argp2) {
85289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85290     return 0;
85291   }
85292   arg2 = *argp2;
85293   {
85294     try {
85295       result = (arg1)->GetFocusGroup(arg2);
85296     } catch (std::out_of_range& e) {
85297       {
85298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85299       };
85300     } catch (std::exception& e) {
85301       {
85302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85303       };
85304     } catch (Dali::DaliException e) {
85305       {
85306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85307       };
85308     } catch (...) {
85309       {
85310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85311       };
85312     }
85313   }
85314
85315   jresult = new Dali::Actor((const Dali::Actor &)result);
85316   return jresult;
85317 }
85318
85319
85320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
85321   void * jresult ;
85322   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85323   Dali::Vector2 result;
85324
85325   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85326   {
85327     try {
85328       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
85329     } catch (std::out_of_range& e) {
85330       {
85331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85332       };
85333     } catch (std::exception& e) {
85334       {
85335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85336       };
85337     } catch (Dali::DaliException e) {
85338       {
85339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85340       };
85341     } catch (...) {
85342       {
85343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85344       };
85345     }
85346   }
85347
85348   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
85349   return jresult;
85350 }
85351
85352
85353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
85354   void * jresult ;
85355   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85356   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
85357
85358   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85359   {
85360     try {
85361       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
85362     } catch (std::out_of_range& e) {
85363       {
85364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85365       };
85366     } catch (std::exception& e) {
85367       {
85368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85369       };
85370     } catch (Dali::DaliException e) {
85371       {
85372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85373       };
85374     } catch (...) {
85375       {
85376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85377       };
85378     }
85379   }
85380
85381   jresult = (void *)result;
85382   return jresult;
85383 }
85384
85385
85386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
85387   void * jresult ;
85388   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85389   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
85390
85391   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85392   {
85393     try {
85394       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
85395     } catch (std::out_of_range& e) {
85396       {
85397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85398       };
85399     } catch (std::exception& e) {
85400       {
85401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85402       };
85403     } catch (Dali::DaliException e) {
85404       {
85405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85406       };
85407     } catch (...) {
85408       {
85409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85410       };
85411     }
85412   }
85413
85414   jresult = (void *)result;
85415   return jresult;
85416 }
85417
85418
85419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
85420   void * jresult ;
85421   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85422   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
85423
85424   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85425   {
85426     try {
85427       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
85428     } catch (std::out_of_range& e) {
85429       {
85430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85431       };
85432     } catch (std::exception& e) {
85433       {
85434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85435       };
85436     } catch (Dali::DaliException e) {
85437       {
85438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85439       };
85440     } catch (...) {
85441       {
85442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85443       };
85444     }
85445   }
85446
85447   jresult = (void *)result;
85448   return jresult;
85449 }
85450
85451
85452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
85453   void * jresult ;
85454   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85455   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85456
85457   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85458   {
85459     try {
85460       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
85461     } catch (std::out_of_range& e) {
85462       {
85463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85464       };
85465     } catch (std::exception& e) {
85466       {
85467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85468       };
85469     } catch (Dali::DaliException e) {
85470       {
85471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85472       };
85473     } catch (...) {
85474       {
85475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85476       };
85477     }
85478   }
85479
85480   jresult = (void *)result;
85481   return jresult;
85482 }
85483
85484
85485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
85486   void * jresult ;
85487   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85488   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85489
85490   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85491   {
85492     try {
85493       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
85494     } catch (std::out_of_range& e) {
85495       {
85496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85497       };
85498     } catch (std::exception& e) {
85499       {
85500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85501       };
85502     } catch (Dali::DaliException e) {
85503       {
85504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85505       };
85506     } catch (...) {
85507       {
85508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85509       };
85510     }
85511   }
85512
85513   jresult = (void *)result;
85514   return jresult;
85515 }
85516
85517
85518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
85519   void * jresult ;
85520   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85521   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85522
85523   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85524   {
85525     try {
85526       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
85527     } catch (std::out_of_range& e) {
85528       {
85529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85530       };
85531     } catch (std::exception& e) {
85532       {
85533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85534       };
85535     } catch (Dali::DaliException e) {
85536       {
85537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85538       };
85539     } catch (...) {
85540       {
85541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85542       };
85543     }
85544   }
85545
85546   jresult = (void *)result;
85547   return jresult;
85548 }
85549
85550
85551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
85552   void * jresult ;
85553   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85554   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85555
85556   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85557   {
85558     try {
85559       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
85560     } catch (std::out_of_range& e) {
85561       {
85562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85563       };
85564     } catch (std::exception& e) {
85565       {
85566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85567       };
85568     } catch (Dali::DaliException e) {
85569       {
85570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85571       };
85572     } catch (...) {
85573       {
85574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85575       };
85576     }
85577   }
85578
85579   jresult = (void *)result;
85580   return jresult;
85581 }
85582
85583
85584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
85585   void * jresult ;
85586   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85587   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85588
85589   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85590   {
85591     try {
85592       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
85593     } catch (std::out_of_range& e) {
85594       {
85595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85596       };
85597     } catch (std::exception& e) {
85598       {
85599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85600       };
85601     } catch (Dali::DaliException e) {
85602       {
85603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85604       };
85605     } catch (...) {
85606       {
85607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85608       };
85609     }
85610   }
85611
85612   jresult = (void *)result;
85613   return jresult;
85614 }
85615
85616
85617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
85618   void * jresult ;
85619   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85620   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85621
85622   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85623   {
85624     try {
85625       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
85626     } catch (std::out_of_range& e) {
85627       {
85628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85629       };
85630     } catch (std::exception& e) {
85631       {
85632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85633       };
85634     } catch (Dali::DaliException e) {
85635       {
85636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85637       };
85638     } catch (...) {
85639       {
85640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85641       };
85642     }
85643   }
85644
85645   jresult = (void *)result;
85646   return jresult;
85647 }
85648
85649
85650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
85651   void * jresult ;
85652   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85653   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85654
85655   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85656   {
85657     try {
85658       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
85659     } catch (std::out_of_range& e) {
85660       {
85661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85662       };
85663     } catch (std::exception& e) {
85664       {
85665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85666       };
85667     } catch (Dali::DaliException e) {
85668       {
85669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85670       };
85671     } catch (...) {
85672       {
85673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85674       };
85675     }
85676   }
85677
85678   jresult = (void *)result;
85679   return jresult;
85680 }
85681
85682
85683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
85684   void * jresult ;
85685   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85686   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85687
85688   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85689   {
85690     try {
85691       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
85692     } catch (std::out_of_range& e) {
85693       {
85694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85695       };
85696     } catch (std::exception& e) {
85697       {
85698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85699       };
85700     } catch (Dali::DaliException e) {
85701       {
85702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85703       };
85704     } catch (...) {
85705       {
85706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85707       };
85708     }
85709   }
85710
85711   jresult = (void *)result;
85712   return jresult;
85713 }
85714
85715
85716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
85717   void * jresult ;
85718   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85719   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85720
85721   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85722   {
85723     try {
85724       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
85725     } catch (std::out_of_range& e) {
85726       {
85727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85728       };
85729     } catch (std::exception& e) {
85730       {
85731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85732       };
85733     } catch (Dali::DaliException e) {
85734       {
85735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85736       };
85737     } catch (...) {
85738       {
85739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85740       };
85741     }
85742   }
85743
85744   jresult = (void *)result;
85745   return jresult;
85746 }
85747
85748
85749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
85750   void * jresult ;
85751   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85752   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85753
85754   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85755   {
85756     try {
85757       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
85758     } catch (std::out_of_range& e) {
85759       {
85760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85761       };
85762     } catch (std::exception& e) {
85763       {
85764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85765       };
85766     } catch (Dali::DaliException e) {
85767       {
85768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85769       };
85770     } catch (...) {
85771       {
85772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85773       };
85774     }
85775   }
85776
85777   jresult = (void *)result;
85778   return jresult;
85779 }
85780
85781
85782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
85783   void * jresult ;
85784   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85785   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85786
85787   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85788   {
85789     try {
85790       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
85791     } catch (std::out_of_range& e) {
85792       {
85793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85794       };
85795     } catch (std::exception& e) {
85796       {
85797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85798       };
85799     } catch (Dali::DaliException e) {
85800       {
85801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85802       };
85803     } catch (...) {
85804       {
85805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85806       };
85807     }
85808   }
85809
85810   jresult = (void *)result;
85811   return jresult;
85812 }
85813
85814
85815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
85816   void * jresult ;
85817   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85818   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85819
85820   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85821   {
85822     try {
85823       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
85824     } catch (std::out_of_range& e) {
85825       {
85826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85827       };
85828     } catch (std::exception& e) {
85829       {
85830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85831       };
85832     } catch (Dali::DaliException e) {
85833       {
85834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85835       };
85836     } catch (...) {
85837       {
85838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85839       };
85840     }
85841   }
85842
85843   jresult = (void *)result;
85844   return jresult;
85845 }
85846
85847
85848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
85849   void * jresult ;
85850   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85851   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85852
85853   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85854   {
85855     try {
85856       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
85857     } catch (std::out_of_range& e) {
85858       {
85859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85860       };
85861     } catch (std::exception& e) {
85862       {
85863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85864       };
85865     } catch (Dali::DaliException e) {
85866       {
85867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85868       };
85869     } catch (...) {
85870       {
85871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85872       };
85873     }
85874   }
85875
85876   jresult = (void *)result;
85877   return jresult;
85878 }
85879
85880
85881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
85882   void * jresult ;
85883   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85884   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85885
85886   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85887   {
85888     try {
85889       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
85890     } catch (std::out_of_range& e) {
85891       {
85892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85893       };
85894     } catch (std::exception& e) {
85895       {
85896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85897       };
85898     } catch (Dali::DaliException e) {
85899       {
85900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85901       };
85902     } catch (...) {
85903       {
85904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85905       };
85906     }
85907   }
85908
85909   jresult = (void *)result;
85910   return jresult;
85911 }
85912
85913
85914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
85915   void * jresult ;
85916   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85917   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85918
85919   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85920   {
85921     try {
85922       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
85923     } catch (std::out_of_range& e) {
85924       {
85925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85926       };
85927     } catch (std::exception& e) {
85928       {
85929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85930       };
85931     } catch (Dali::DaliException e) {
85932       {
85933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85934       };
85935     } catch (...) {
85936       {
85937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85938       };
85939     }
85940   }
85941
85942   jresult = (void *)result;
85943   return jresult;
85944 }
85945
85946
85947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
85948   void * jresult ;
85949   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85950   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85951
85952   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85953   {
85954     try {
85955       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
85956     } catch (std::out_of_range& e) {
85957       {
85958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85959       };
85960     } catch (std::exception& e) {
85961       {
85962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85963       };
85964     } catch (Dali::DaliException e) {
85965       {
85966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85967       };
85968     } catch (...) {
85969       {
85970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85971       };
85972     }
85973   }
85974
85975   jresult = (void *)result;
85976   return jresult;
85977 }
85978
85979
85980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
85981   void * jresult ;
85982   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85983   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85984
85985   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85986   {
85987     try {
85988       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
85989     } catch (std::out_of_range& e) {
85990       {
85991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85992       };
85993     } catch (std::exception& e) {
85994       {
85995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85996       };
85997     } catch (Dali::DaliException e) {
85998       {
85999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86000       };
86001     } catch (...) {
86002       {
86003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86004       };
86005     }
86006   }
86007
86008   jresult = (void *)result;
86009   return jresult;
86010 }
86011
86012
86013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
86014   void * jresult ;
86015   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86016   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86017
86018   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86019   {
86020     try {
86021       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
86022     } catch (std::out_of_range& e) {
86023       {
86024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86025       };
86026     } catch (std::exception& e) {
86027       {
86028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86029       };
86030     } catch (Dali::DaliException e) {
86031       {
86032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86033       };
86034     } catch (...) {
86035       {
86036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86037       };
86038     }
86039   }
86040
86041   jresult = (void *)result;
86042   return jresult;
86043 }
86044
86045
86046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
86047   void * jresult ;
86048   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86049   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86050
86051   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86052   {
86053     try {
86054       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
86055     } catch (std::out_of_range& e) {
86056       {
86057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86058       };
86059     } catch (std::exception& e) {
86060       {
86061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86062       };
86063     } catch (Dali::DaliException e) {
86064       {
86065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86066       };
86067     } catch (...) {
86068       {
86069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86070       };
86071     }
86072   }
86073
86074   jresult = (void *)result;
86075   return jresult;
86076 }
86077
86078
86079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
86080   void * jresult ;
86081   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86082   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86083
86084   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86085   {
86086     try {
86087       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
86088     } catch (std::out_of_range& e) {
86089       {
86090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86091       };
86092     } catch (std::exception& e) {
86093       {
86094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86095       };
86096     } catch (Dali::DaliException e) {
86097       {
86098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86099       };
86100     } catch (...) {
86101       {
86102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86103       };
86104     }
86105   }
86106
86107   jresult = (void *)result;
86108   return jresult;
86109 }
86110
86111
86112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
86113   void * jresult ;
86114   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86115   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86116
86117   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86118   {
86119     try {
86120       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
86121     } catch (std::out_of_range& e) {
86122       {
86123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86124       };
86125     } catch (std::exception& e) {
86126       {
86127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86128       };
86129     } catch (Dali::DaliException e) {
86130       {
86131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86132       };
86133     } catch (...) {
86134       {
86135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86136       };
86137     }
86138   }
86139
86140   jresult = (void *)result;
86141   return jresult;
86142 }
86143
86144
86145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
86146   void * jresult ;
86147   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86148   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86149
86150   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86151   {
86152     try {
86153       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
86154     } catch (std::out_of_range& e) {
86155       {
86156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86157       };
86158     } catch (std::exception& e) {
86159       {
86160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86161       };
86162     } catch (Dali::DaliException e) {
86163       {
86164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86165       };
86166     } catch (...) {
86167       {
86168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86169       };
86170     }
86171   }
86172
86173   jresult = (void *)result;
86174   return jresult;
86175 }
86176
86177
86178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
86179   void * jresult ;
86180   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86181   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86182
86183   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86184   {
86185     try {
86186       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
86187     } catch (std::out_of_range& e) {
86188       {
86189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86190       };
86191     } catch (std::exception& e) {
86192       {
86193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86194       };
86195     } catch (Dali::DaliException e) {
86196       {
86197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86198       };
86199     } catch (...) {
86200       {
86201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86202       };
86203     }
86204   }
86205
86206   jresult = (void *)result;
86207   return jresult;
86208 }
86209
86210
86211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
86212   void * jresult ;
86213   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86214   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86215
86216   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86217   {
86218     try {
86219       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
86220     } catch (std::out_of_range& e) {
86221       {
86222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86223       };
86224     } catch (std::exception& e) {
86225       {
86226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86227       };
86228     } catch (Dali::DaliException e) {
86229       {
86230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86231       };
86232     } catch (...) {
86233       {
86234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86235       };
86236     }
86237   }
86238
86239   jresult = (void *)result;
86240   return jresult;
86241 }
86242
86243
86244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
86245   void * jresult ;
86246   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86247   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86248
86249   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86250   {
86251     try {
86252       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
86253     } catch (std::out_of_range& e) {
86254       {
86255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86256       };
86257     } catch (std::exception& e) {
86258       {
86259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86260       };
86261     } catch (Dali::DaliException e) {
86262       {
86263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86264       };
86265     } catch (...) {
86266       {
86267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86268       };
86269     }
86270   }
86271
86272   jresult = (void *)result;
86273   return jresult;
86274 }
86275
86276
86277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
86278   void * jresult ;
86279   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86280   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86281
86282   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86283   {
86284     try {
86285       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
86286     } catch (std::out_of_range& e) {
86287       {
86288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86289       };
86290     } catch (std::exception& e) {
86291       {
86292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86293       };
86294     } catch (Dali::DaliException e) {
86295       {
86296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86297       };
86298     } catch (...) {
86299       {
86300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86301       };
86302     }
86303   }
86304
86305   jresult = (void *)result;
86306   return jresult;
86307 }
86308
86309
86310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
86311   void * jresult ;
86312   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86313   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
86314
86315   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86316   {
86317     try {
86318       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
86319     } catch (std::out_of_range& e) {
86320       {
86321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86322       };
86323     } catch (std::exception& e) {
86324       {
86325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86326       };
86327     } catch (Dali::DaliException e) {
86328       {
86329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86330       };
86331     } catch (...) {
86332       {
86333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86334       };
86335     }
86336   }
86337
86338   jresult = (void *)result;
86339   return jresult;
86340 }
86341
86342
86343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
86344   void * jresult ;
86345   Dali::Toolkit::StyleManager *result = 0 ;
86346
86347   {
86348     try {
86349       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
86350     } catch (std::out_of_range& e) {
86351       {
86352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86353       };
86354     } catch (std::exception& e) {
86355       {
86356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86357       };
86358     } catch (Dali::DaliException e) {
86359       {
86360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86361       };
86362     } catch (...) {
86363       {
86364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86365       };
86366     }
86367   }
86368
86369   jresult = (void *)result;
86370   return jresult;
86371 }
86372
86373
86374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
86375   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86376
86377   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86378   {
86379     try {
86380       delete arg1;
86381     } catch (std::out_of_range& e) {
86382       {
86383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86384       };
86385     } catch (std::exception& e) {
86386       {
86387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86388       };
86389     } catch (Dali::DaliException e) {
86390       {
86391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86392       };
86393     } catch (...) {
86394       {
86395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86396       };
86397     }
86398   }
86399
86400 }
86401
86402
86403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
86404   void * jresult ;
86405   Dali::Toolkit::StyleManager result;
86406
86407   {
86408     try {
86409       result = Dali::Toolkit::StyleManager::Get();
86410     } catch (std::out_of_range& e) {
86411       {
86412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86413       };
86414     } catch (std::exception& e) {
86415       {
86416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86417       };
86418     } catch (Dali::DaliException e) {
86419       {
86420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86421       };
86422     } catch (...) {
86423       {
86424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86425       };
86426     }
86427   }
86428
86429   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
86430   return jresult;
86431 }
86432
86433
86434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
86435   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86436   std::string *arg2 = 0 ;
86437
86438   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86439   if (!jarg2) {
86440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86441     return ;
86442   }
86443   std::string arg2_str(jarg2);
86444   arg2 = &arg2_str;
86445   {
86446     try {
86447       (arg1)->ApplyTheme((std::string const &)*arg2);
86448     } catch (std::out_of_range& e) {
86449       {
86450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86451       };
86452     } catch (std::exception& e) {
86453       {
86454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86455       };
86456     } catch (Dali::DaliException e) {
86457       {
86458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86459       };
86460     } catch (...) {
86461       {
86462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86463       };
86464     }
86465   }
86466
86467
86468   //argout typemap for const std::string&
86469
86470 }
86471
86472
86473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
86474   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86475
86476   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86477   {
86478     try {
86479       (arg1)->ApplyDefaultTheme();
86480     } catch (std::out_of_range& e) {
86481       {
86482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86483       };
86484     } catch (std::exception& e) {
86485       {
86486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86487       };
86488     } catch (Dali::DaliException e) {
86489       {
86490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86491       };
86492     } catch (...) {
86493       {
86494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86495       };
86496     }
86497   }
86498
86499 }
86500
86501
86502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86503   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86504   std::string *arg2 = 0 ;
86505   Dali::Property::Value *arg3 = 0 ;
86506
86507   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86508   if (!jarg2) {
86509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86510     return ;
86511   }
86512   std::string arg2_str(jarg2);
86513   arg2 = &arg2_str;
86514   arg3 = (Dali::Property::Value *)jarg3;
86515   if (!arg3) {
86516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
86517     return ;
86518   }
86519   {
86520     try {
86521       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
86522     } catch (std::out_of_range& e) {
86523       {
86524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86525       };
86526     } catch (std::exception& e) {
86527       {
86528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86529       };
86530     } catch (Dali::DaliException e) {
86531       {
86532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86533       };
86534     } catch (...) {
86535       {
86536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86537       };
86538     }
86539   }
86540
86541
86542   //argout typemap for const std::string&
86543
86544 }
86545
86546
86547 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86548   unsigned int jresult ;
86549   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86550   std::string *arg2 = 0 ;
86551   Dali::Property::Value *arg3 = 0 ;
86552   bool result;
86553
86554   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86555   if (!jarg2) {
86556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86557     return 0;
86558   }
86559   std::string arg2_str(jarg2);
86560   arg2 = &arg2_str;
86561   arg3 = (Dali::Property::Value *)jarg3;
86562   if (!arg3) {
86563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
86564     return 0;
86565   }
86566   {
86567     try {
86568       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
86569     } catch (std::out_of_range& e) {
86570       {
86571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86572       };
86573     } catch (std::exception& e) {
86574       {
86575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86576       };
86577     } catch (Dali::DaliException e) {
86578       {
86579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86580       };
86581     } catch (...) {
86582       {
86583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86584       };
86585     }
86586   }
86587
86588   jresult = result;
86589
86590   //argout typemap for const std::string&
86591
86592   return jresult;
86593 }
86594
86595
86596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
86597   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86598   Dali::Toolkit::Control arg2 ;
86599   std::string *arg3 = 0 ;
86600   std::string *arg4 = 0 ;
86601   Dali::Toolkit::Control *argp2 ;
86602
86603   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86604   argp2 = (Dali::Toolkit::Control *)jarg2;
86605   if (!argp2) {
86606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
86607     return ;
86608   }
86609   arg2 = *argp2;
86610   if (!jarg3) {
86611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86612     return ;
86613   }
86614   std::string arg3_str(jarg3);
86615   arg3 = &arg3_str;
86616   if (!jarg4) {
86617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86618     return ;
86619   }
86620   std::string arg4_str(jarg4);
86621   arg4 = &arg4_str;
86622   {
86623     try {
86624       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
86625     } catch (std::out_of_range& e) {
86626       {
86627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86628       };
86629     } catch (std::exception& e) {
86630       {
86631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86632       };
86633     } catch (Dali::DaliException e) {
86634       {
86635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86636       };
86637     } catch (...) {
86638       {
86639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86640       };
86641     }
86642   }
86643
86644
86645   //argout typemap for const std::string&
86646
86647
86648   //argout typemap for const std::string&
86649
86650 }
86651
86652
86653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
86654   void * jresult ;
86655   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86656   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
86657
86658   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86659   {
86660     try {
86661       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
86662     } catch (std::out_of_range& e) {
86663       {
86664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86665       };
86666     } catch (std::exception& e) {
86667       {
86668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86669       };
86670     } catch (Dali::DaliException e) {
86671       {
86672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86673       };
86674     } catch (...) {
86675       {
86676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86677       };
86678     }
86679   }
86680
86681   jresult = (void *)result;
86682   return jresult;
86683 }
86684
86685
86686 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
86687   int jresult ;
86688   int result;
86689
86690   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
86691   jresult = (int)result;
86692   return jresult;
86693 }
86694
86695
86696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
86697   int jresult ;
86698   int result;
86699
86700   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
86701   jresult = (int)result;
86702   return jresult;
86703 }
86704
86705
86706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
86707   int jresult ;
86708   int result;
86709
86710   result = (int)Dali::Toolkit::Slider::Property::VALUE;
86711   jresult = (int)result;
86712   return jresult;
86713 }
86714
86715
86716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
86717   int jresult ;
86718   int result;
86719
86720   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
86721   jresult = (int)result;
86722   return jresult;
86723 }
86724
86725
86726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
86727   int jresult ;
86728   int result;
86729
86730   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
86731   jresult = (int)result;
86732   return jresult;
86733 }
86734
86735
86736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
86737   int jresult ;
86738   int result;
86739
86740   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
86741   jresult = (int)result;
86742   return jresult;
86743 }
86744
86745
86746 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
86747   int jresult ;
86748   int result;
86749
86750   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
86751   jresult = (int)result;
86752   return jresult;
86753 }
86754
86755
86756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
86757   int jresult ;
86758   int result;
86759
86760   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
86761   jresult = (int)result;
86762   return jresult;
86763 }
86764
86765
86766 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
86767   int jresult ;
86768   int result;
86769
86770   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
86771   jresult = (int)result;
86772   return jresult;
86773 }
86774
86775
86776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
86777   int jresult ;
86778   int result;
86779
86780   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
86781   jresult = (int)result;
86782   return jresult;
86783 }
86784
86785
86786 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
86787   int jresult ;
86788   int result;
86789
86790   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
86791   jresult = (int)result;
86792   return jresult;
86793 }
86794
86795
86796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
86797   int jresult ;
86798   int result;
86799
86800   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
86801   jresult = (int)result;
86802   return jresult;
86803 }
86804
86805
86806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
86807   int jresult ;
86808   int result;
86809
86810   result = (int)Dali::Toolkit::Slider::Property::MARKS;
86811   jresult = (int)result;
86812   return jresult;
86813 }
86814
86815
86816 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
86817   int jresult ;
86818   int result;
86819
86820   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
86821   jresult = (int)result;
86822   return jresult;
86823 }
86824
86825
86826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
86827   int jresult ;
86828   int result;
86829
86830   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
86831   jresult = (int)result;
86832   return jresult;
86833 }
86834
86835
86836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
86837   void * jresult ;
86838   Dali::Toolkit::Slider::Property *result = 0 ;
86839
86840   {
86841     try {
86842       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
86843     } catch (std::out_of_range& e) {
86844       {
86845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86846       };
86847     } catch (std::exception& e) {
86848       {
86849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86850       };
86851     } catch (Dali::DaliException e) {
86852       {
86853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86854       };
86855     } catch (...) {
86856       {
86857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86858       };
86859     }
86860   }
86861
86862   jresult = (void *)result;
86863   return jresult;
86864 }
86865
86866
86867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
86868   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
86869
86870   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
86871   {
86872     try {
86873       delete arg1;
86874     } catch (std::out_of_range& e) {
86875       {
86876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86877       };
86878     } catch (std::exception& e) {
86879       {
86880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86881       };
86882     } catch (Dali::DaliException e) {
86883       {
86884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86885       };
86886     } catch (...) {
86887       {
86888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86889       };
86890     }
86891   }
86892
86893 }
86894
86895
86896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
86897   void * jresult ;
86898   Dali::Toolkit::Slider result;
86899
86900   {
86901     try {
86902       result = Dali::Toolkit::Slider::New();
86903     } catch (std::out_of_range& e) {
86904       {
86905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86906       };
86907     } catch (std::exception& e) {
86908       {
86909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86910       };
86911     } catch (Dali::DaliException e) {
86912       {
86913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86914       };
86915     } catch (...) {
86916       {
86917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86918       };
86919     }
86920   }
86921
86922   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
86923   return jresult;
86924 }
86925
86926
86927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
86928   void * jresult ;
86929   Dali::Toolkit::Slider *result = 0 ;
86930
86931   {
86932     try {
86933       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
86934     } catch (std::out_of_range& e) {
86935       {
86936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86937       };
86938     } catch (std::exception& e) {
86939       {
86940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86941       };
86942     } catch (Dali::DaliException e) {
86943       {
86944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86945       };
86946     } catch (...) {
86947       {
86948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86949       };
86950     }
86951   }
86952
86953   jresult = (void *)result;
86954   return jresult;
86955 }
86956
86957
86958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
86959   void * jresult ;
86960   Dali::Toolkit::Slider *arg1 = 0 ;
86961   Dali::Toolkit::Slider *result = 0 ;
86962
86963   arg1 = (Dali::Toolkit::Slider *)jarg1;
86964   if (!arg1) {
86965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
86966     return 0;
86967   }
86968   {
86969     try {
86970       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
86971     } catch (std::out_of_range& e) {
86972       {
86973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86974       };
86975     } catch (std::exception& e) {
86976       {
86977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86978       };
86979     } catch (Dali::DaliException e) {
86980       {
86981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86982       };
86983     } catch (...) {
86984       {
86985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86986       };
86987     }
86988   }
86989
86990   jresult = (void *)result;
86991   return jresult;
86992 }
86993
86994
86995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
86996   void * jresult ;
86997   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86998   Dali::Toolkit::Slider *arg2 = 0 ;
86999   Dali::Toolkit::Slider *result = 0 ;
87000
87001   arg1 = (Dali::Toolkit::Slider *)jarg1;
87002   arg2 = (Dali::Toolkit::Slider *)jarg2;
87003   if (!arg2) {
87004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
87005     return 0;
87006   }
87007   {
87008     try {
87009       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
87010     } catch (std::out_of_range& e) {
87011       {
87012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87013       };
87014     } catch (std::exception& e) {
87015       {
87016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87017       };
87018     } catch (Dali::DaliException e) {
87019       {
87020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87021       };
87022     } catch (...) {
87023       {
87024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87025       };
87026     }
87027   }
87028
87029   jresult = (void *)result;
87030   return jresult;
87031 }
87032
87033
87034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
87035   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87036
87037   arg1 = (Dali::Toolkit::Slider *)jarg1;
87038   {
87039     try {
87040       delete arg1;
87041     } catch (std::out_of_range& e) {
87042       {
87043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87044       };
87045     } catch (std::exception& e) {
87046       {
87047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87048       };
87049     } catch (Dali::DaliException e) {
87050       {
87051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87052       };
87053     } catch (...) {
87054       {
87055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87056       };
87057     }
87058   }
87059
87060 }
87061
87062
87063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
87064   void * jresult ;
87065   Dali::BaseHandle arg1 ;
87066   Dali::BaseHandle *argp1 ;
87067   Dali::Toolkit::Slider result;
87068
87069   argp1 = (Dali::BaseHandle *)jarg1;
87070   if (!argp1) {
87071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87072     return 0;
87073   }
87074   arg1 = *argp1;
87075   {
87076     try {
87077       result = Dali::Toolkit::Slider::DownCast(arg1);
87078     } catch (std::out_of_range& e) {
87079       {
87080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87081       };
87082     } catch (std::exception& e) {
87083       {
87084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87085       };
87086     } catch (Dali::DaliException e) {
87087       {
87088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87089       };
87090     } catch (...) {
87091       {
87092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87093       };
87094     }
87095   }
87096
87097   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
87098   return jresult;
87099 }
87100
87101
87102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
87103   void * jresult ;
87104   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87105   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
87106
87107   arg1 = (Dali::Toolkit::Slider *)jarg1;
87108   {
87109     try {
87110       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
87111     } catch (std::out_of_range& e) {
87112       {
87113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87114       };
87115     } catch (std::exception& e) {
87116       {
87117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87118       };
87119     } catch (Dali::DaliException e) {
87120       {
87121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87122       };
87123     } catch (...) {
87124       {
87125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87126       };
87127     }
87128   }
87129
87130   jresult = (void *)result;
87131   return jresult;
87132 }
87133
87134
87135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
87136   void * jresult ;
87137   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87138   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
87139
87140   arg1 = (Dali::Toolkit::Slider *)jarg1;
87141   {
87142     try {
87143       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
87144     } catch (std::out_of_range& e) {
87145       {
87146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87147       };
87148     } catch (std::exception& e) {
87149       {
87150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87151       };
87152     } catch (Dali::DaliException e) {
87153       {
87154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87155       };
87156     } catch (...) {
87157       {
87158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87159       };
87160     }
87161   }
87162
87163   jresult = (void *)result;
87164   return jresult;
87165 }
87166
87167
87168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
87169   void * jresult ;
87170   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87171   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
87172
87173   arg1 = (Dali::Toolkit::Slider *)jarg1;
87174   {
87175     try {
87176       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
87177     } catch (std::out_of_range& e) {
87178       {
87179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87180       };
87181     } catch (std::exception& e) {
87182       {
87183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87184       };
87185     } catch (Dali::DaliException e) {
87186       {
87187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87188       };
87189     } catch (...) {
87190       {
87191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87192       };
87193     }
87194   }
87195
87196   jresult = (void *)result;
87197   return jresult;
87198 }
87199
87200
87201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
87202   int jresult ;
87203   int result;
87204
87205   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
87206   jresult = (int)result;
87207   return jresult;
87208 }
87209
87210
87211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
87212   int jresult ;
87213   int result;
87214
87215   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
87216   jresult = (int)result;
87217   return jresult;
87218 }
87219
87220
87221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
87222   int jresult ;
87223   int result;
87224
87225   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
87226   jresult = (int)result;
87227   return jresult;
87228 }
87229
87230
87231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
87232   int jresult ;
87233   int result;
87234
87235   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
87236   jresult = (int)result;
87237   return jresult;
87238 }
87239
87240
87241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
87242   int result;
87243
87244   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
87245
87246   return result;
87247 }
87248
87249
87250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
87251   void * jresult ;
87252   Dali::Toolkit::VideoView::Property *result = 0 ;
87253
87254   {
87255     try {
87256       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
87257     } catch (std::out_of_range& e) {
87258       {
87259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87260       };
87261     } catch (std::exception& e) {
87262       {
87263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87264       };
87265     } catch (Dali::DaliException e) {
87266       {
87267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87268       };
87269     } catch (...) {
87270       {
87271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87272       };
87273     }
87274   }
87275
87276   jresult = (void *)result;
87277   return jresult;
87278 }
87279
87280
87281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
87282   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
87283
87284   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
87285   {
87286     try {
87287       delete arg1;
87288     } catch (std::out_of_range& e) {
87289       {
87290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87291       };
87292     } catch (std::exception& e) {
87293       {
87294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87295       };
87296     } catch (Dali::DaliException e) {
87297       {
87298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87299       };
87300     } catch (...) {
87301       {
87302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87303       };
87304     }
87305   }
87306
87307 }
87308
87309
87310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
87311   void * jresult ;
87312   Dali::Toolkit::VideoView result;
87313
87314   {
87315     try {
87316       result = Dali::Toolkit::VideoView::New();
87317     } catch (std::out_of_range& e) {
87318       {
87319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87320       };
87321     } catch (std::exception& e) {
87322       {
87323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87324       };
87325     } catch (Dali::DaliException e) {
87326       {
87327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87328       };
87329     } catch (...) {
87330       {
87331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87332       };
87333     }
87334   }
87335
87336   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87337   return jresult;
87338 }
87339
87340
87341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
87342   void * jresult ;
87343   std::string *arg1 = 0 ;
87344   Dali::Toolkit::VideoView result;
87345
87346   if (!jarg1) {
87347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87348     return 0;
87349   }
87350   std::string arg1_str(jarg1);
87351   arg1 = &arg1_str;
87352   {
87353     try {
87354       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
87355     } catch (std::out_of_range& e) {
87356       {
87357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87358       };
87359     } catch (std::exception& e) {
87360       {
87361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87362       };
87363     } catch (Dali::DaliException e) {
87364       {
87365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87366       };
87367     } catch (...) {
87368       {
87369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87370       };
87371     }
87372   }
87373
87374   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87375
87376   //argout typemap for const std::string&
87377
87378   return jresult;
87379 }
87380
87381
87382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
87383   void * jresult ;
87384   Dali::Toolkit::VideoView *result = 0 ;
87385
87386   {
87387     try {
87388       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
87389     } catch (std::out_of_range& e) {
87390       {
87391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87392       };
87393     } catch (std::exception& e) {
87394       {
87395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87396       };
87397     } catch (Dali::DaliException e) {
87398       {
87399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87400       };
87401     } catch (...) {
87402       {
87403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87404       };
87405     }
87406   }
87407
87408   jresult = (void *)result;
87409   return jresult;
87410 }
87411
87412
87413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
87414   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87415
87416   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87417   {
87418     try {
87419       delete arg1;
87420     } catch (std::out_of_range& e) {
87421       {
87422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87423       };
87424     } catch (std::exception& e) {
87425       {
87426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87427       };
87428     } catch (Dali::DaliException e) {
87429       {
87430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87431       };
87432     } catch (...) {
87433       {
87434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87435       };
87436     }
87437   }
87438
87439 }
87440
87441
87442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
87443   void * jresult ;
87444   Dali::Toolkit::VideoView *arg1 = 0 ;
87445   Dali::Toolkit::VideoView *result = 0 ;
87446
87447   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87448   if (!arg1) {
87449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87450     return 0;
87451   }
87452   {
87453     try {
87454       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
87455     } catch (std::out_of_range& e) {
87456       {
87457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87458       };
87459     } catch (std::exception& e) {
87460       {
87461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87462       };
87463     } catch (Dali::DaliException e) {
87464       {
87465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87466       };
87467     } catch (...) {
87468       {
87469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87470       };
87471     }
87472   }
87473
87474   jresult = (void *)result;
87475   return jresult;
87476 }
87477
87478
87479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
87480   void * jresult ;
87481   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87482   Dali::Toolkit::VideoView *arg2 = 0 ;
87483   Dali::Toolkit::VideoView *result = 0 ;
87484
87485   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87486   arg2 = (Dali::Toolkit::VideoView *)jarg2;
87487   if (!arg2) {
87488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87489     return 0;
87490   }
87491   {
87492     try {
87493       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
87494     } catch (std::out_of_range& e) {
87495       {
87496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87497       };
87498     } catch (std::exception& e) {
87499       {
87500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87501       };
87502     } catch (Dali::DaliException e) {
87503       {
87504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87505       };
87506     } catch (...) {
87507       {
87508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87509       };
87510     }
87511   }
87512
87513   jresult = (void *)result;
87514   return jresult;
87515 }
87516
87517
87518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
87519   void * jresult ;
87520   Dali::BaseHandle arg1 ;
87521   Dali::BaseHandle *argp1 ;
87522   Dali::Toolkit::VideoView result;
87523
87524   argp1 = (Dali::BaseHandle *)jarg1;
87525   if (!argp1) {
87526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87527     return 0;
87528   }
87529   arg1 = *argp1;
87530   {
87531     try {
87532       result = Dali::Toolkit::VideoView::DownCast(arg1);
87533     } catch (std::out_of_range& e) {
87534       {
87535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87536       };
87537     } catch (std::exception& e) {
87538       {
87539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87540       };
87541     } catch (Dali::DaliException e) {
87542       {
87543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87544       };
87545     } catch (...) {
87546       {
87547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87548       };
87549     }
87550   }
87551
87552   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87553   return jresult;
87554 }
87555
87556
87557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
87558   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87559
87560   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87561   {
87562     try {
87563       (arg1)->Play();
87564     } catch (std::out_of_range& e) {
87565       {
87566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87567       };
87568     } catch (std::exception& e) {
87569       {
87570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87571       };
87572     } catch (Dali::DaliException e) {
87573       {
87574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87575       };
87576     } catch (...) {
87577       {
87578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87579       };
87580     }
87581   }
87582
87583 }
87584
87585
87586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
87587   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87588
87589   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87590   {
87591     try {
87592       (arg1)->Pause();
87593     } catch (std::out_of_range& e) {
87594       {
87595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87596       };
87597     } catch (std::exception& e) {
87598       {
87599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87600       };
87601     } catch (Dali::DaliException e) {
87602       {
87603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87604       };
87605     } catch (...) {
87606       {
87607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87608       };
87609     }
87610   }
87611
87612 }
87613
87614
87615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
87616   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87617
87618   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87619   {
87620     try {
87621       (arg1)->Stop();
87622     } catch (std::out_of_range& e) {
87623       {
87624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87625       };
87626     } catch (std::exception& e) {
87627       {
87628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87629       };
87630     } catch (Dali::DaliException e) {
87631       {
87632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87633       };
87634     } catch (...) {
87635       {
87636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87637       };
87638     }
87639   }
87640
87641 }
87642
87643
87644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
87645   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87646   int arg2 ;
87647
87648   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87649   arg2 = (int)jarg2;
87650   {
87651     try {
87652       (arg1)->Forward(arg2);
87653     } catch (std::out_of_range& e) {
87654       {
87655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87656       };
87657     } catch (std::exception& e) {
87658       {
87659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87660       };
87661     } catch (Dali::DaliException e) {
87662       {
87663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87664       };
87665     } catch (...) {
87666       {
87667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87668       };
87669     }
87670   }
87671
87672 }
87673
87674
87675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
87676   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87677   int arg2 ;
87678
87679   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87680   arg2 = (int)jarg2;
87681   {
87682     try {
87683       (arg1)->Backward(arg2);
87684     } catch (std::out_of_range& e) {
87685       {
87686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87687       };
87688     } catch (std::exception& e) {
87689       {
87690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87691       };
87692     } catch (Dali::DaliException e) {
87693       {
87694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87695       };
87696     } catch (...) {
87697       {
87698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87699       };
87700     }
87701   }
87702
87703 }
87704
87705
87706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
87707   void * jresult ;
87708   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87709   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
87710
87711   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87712   {
87713     try {
87714       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
87715     } catch (std::out_of_range& e) {
87716       {
87717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87718       };
87719     } catch (std::exception& e) {
87720       {
87721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87722       };
87723     } catch (Dali::DaliException e) {
87724       {
87725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87726       };
87727     } catch (...) {
87728       {
87729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87730       };
87731     }
87732   }
87733
87734   jresult = (void *)result;
87735   return jresult;
87736 }
87737
87738
87739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
87740   int jresult ;
87741   int result;
87742
87743   result = (int)Dali::Toolkit::Popup::Property::TITLE;
87744   jresult = (int)result;
87745   return jresult;
87746 }
87747
87748
87749 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
87750   int jresult ;
87751   int result;
87752
87753   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
87754   jresult = (int)result;
87755   return jresult;
87756 }
87757
87758
87759 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
87760   int jresult ;
87761   int result;
87762
87763   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
87764   jresult = (int)result;
87765   return jresult;
87766 }
87767
87768
87769 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
87770   int jresult ;
87771   int result;
87772
87773   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
87774   jresult = (int)result;
87775   return jresult;
87776 }
87777
87778
87779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
87780   int jresult ;
87781   int result;
87782
87783   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
87784   jresult = (int)result;
87785   return jresult;
87786 }
87787
87788
87789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
87790   int jresult ;
87791   int result;
87792
87793   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
87794   jresult = (int)result;
87795   return jresult;
87796 }
87797
87798
87799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
87800   int jresult ;
87801   int result;
87802
87803   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
87804   jresult = (int)result;
87805   return jresult;
87806 }
87807
87808
87809 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
87810   int jresult ;
87811   int result;
87812
87813   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
87814   jresult = (int)result;
87815   return jresult;
87816 }
87817
87818
87819 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
87820   int jresult ;
87821   int result;
87822
87823   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
87824   jresult = (int)result;
87825   return jresult;
87826 }
87827
87828
87829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
87830   int jresult ;
87831   int result;
87832
87833   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
87834   jresult = (int)result;
87835   return jresult;
87836 }
87837
87838
87839 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
87840   int jresult ;
87841   int result;
87842
87843   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
87844   jresult = (int)result;
87845   return jresult;
87846 }
87847
87848
87849 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
87850   int jresult ;
87851   int result;
87852
87853   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
87854   jresult = (int)result;
87855   return jresult;
87856 }
87857
87858
87859 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
87860   int jresult ;
87861   int result;
87862
87863   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
87864   jresult = (int)result;
87865   return jresult;
87866 }
87867
87868
87869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
87870   int jresult ;
87871   int result;
87872
87873   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
87874   jresult = (int)result;
87875   return jresult;
87876 }
87877
87878
87879 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
87880   int jresult ;
87881   int result;
87882
87883   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
87884   jresult = (int)result;
87885   return jresult;
87886 }
87887
87888
87889 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
87890   int jresult ;
87891   int result;
87892
87893   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
87894   jresult = (int)result;
87895   return jresult;
87896 }
87897
87898
87899 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
87900   int jresult ;
87901   int result;
87902
87903   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
87904   jresult = (int)result;
87905   return jresult;
87906 }
87907
87908
87909 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
87910   int jresult ;
87911   int result;
87912
87913   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
87914   jresult = (int)result;
87915   return jresult;
87916 }
87917
87918
87919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
87920   int jresult ;
87921   int result;
87922
87923   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
87924   jresult = (int)result;
87925   return jresult;
87926 }
87927
87928
87929 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
87930   int jresult ;
87931   int result;
87932
87933   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
87934   jresult = (int)result;
87935   return jresult;
87936 }
87937
87938
87939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
87940   int jresult ;
87941   int result;
87942
87943   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
87944   jresult = (int)result;
87945   return jresult;
87946 }
87947
87948
87949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
87950   void * jresult ;
87951   Dali::Toolkit::Popup::Property *result = 0 ;
87952
87953   {
87954     try {
87955       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
87956     } catch (std::out_of_range& e) {
87957       {
87958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87959       };
87960     } catch (std::exception& e) {
87961       {
87962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87963       };
87964     } catch (Dali::DaliException e) {
87965       {
87966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87967       };
87968     } catch (...) {
87969       {
87970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87971       };
87972     }
87973   }
87974
87975   jresult = (void *)result;
87976   return jresult;
87977 }
87978
87979
87980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
87981   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
87982
87983   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
87984   {
87985     try {
87986       delete arg1;
87987     } catch (std::out_of_range& e) {
87988       {
87989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87990       };
87991     } catch (std::exception& e) {
87992       {
87993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87994       };
87995     } catch (Dali::DaliException e) {
87996       {
87997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87998       };
87999     } catch (...) {
88000       {
88001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88002       };
88003     }
88004   }
88005
88006 }
88007
88008
88009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
88010   void * jresult ;
88011   Dali::Toolkit::Popup *result = 0 ;
88012
88013   {
88014     try {
88015       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
88016     } catch (std::out_of_range& e) {
88017       {
88018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88019       };
88020     } catch (std::exception& e) {
88021       {
88022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88023       };
88024     } catch (Dali::DaliException e) {
88025       {
88026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88027       };
88028     } catch (...) {
88029       {
88030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88031       };
88032     }
88033   }
88034
88035   jresult = (void *)result;
88036   return jresult;
88037 }
88038
88039
88040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
88041   void * jresult ;
88042   Dali::Toolkit::Popup result;
88043
88044   {
88045     try {
88046       result = Dali::Toolkit::Popup::New();
88047     } catch (std::out_of_range& e) {
88048       {
88049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88050       };
88051     } catch (std::exception& e) {
88052       {
88053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88054       };
88055     } catch (Dali::DaliException e) {
88056       {
88057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88058       };
88059     } catch (...) {
88060       {
88061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88062       };
88063     }
88064   }
88065
88066   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
88067   return jresult;
88068 }
88069
88070
88071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
88072   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88073
88074   arg1 = (Dali::Toolkit::Popup *)jarg1;
88075   {
88076     try {
88077       delete arg1;
88078     } catch (std::out_of_range& e) {
88079       {
88080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88081       };
88082     } catch (std::exception& e) {
88083       {
88084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88085       };
88086     } catch (Dali::DaliException e) {
88087       {
88088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88089       };
88090     } catch (...) {
88091       {
88092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88093       };
88094     }
88095   }
88096
88097 }
88098
88099
88100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
88101   void * jresult ;
88102   Dali::Toolkit::Popup *arg1 = 0 ;
88103   Dali::Toolkit::Popup *result = 0 ;
88104
88105   arg1 = (Dali::Toolkit::Popup *)jarg1;
88106   if (!arg1) {
88107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
88108     return 0;
88109   }
88110   {
88111     try {
88112       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
88113     } catch (std::out_of_range& e) {
88114       {
88115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88116       };
88117     } catch (std::exception& e) {
88118       {
88119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88120       };
88121     } catch (Dali::DaliException e) {
88122       {
88123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88124       };
88125     } catch (...) {
88126       {
88127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88128       };
88129     }
88130   }
88131
88132   jresult = (void *)result;
88133   return jresult;
88134 }
88135
88136
88137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
88138   void * jresult ;
88139   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88140   Dali::Toolkit::Popup *arg2 = 0 ;
88141   Dali::Toolkit::Popup *result = 0 ;
88142
88143   arg1 = (Dali::Toolkit::Popup *)jarg1;
88144   arg2 = (Dali::Toolkit::Popup *)jarg2;
88145   if (!arg2) {
88146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
88147     return 0;
88148   }
88149   {
88150     try {
88151       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
88152     } catch (std::out_of_range& e) {
88153       {
88154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88155       };
88156     } catch (std::exception& e) {
88157       {
88158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88159       };
88160     } catch (Dali::DaliException e) {
88161       {
88162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88163       };
88164     } catch (...) {
88165       {
88166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88167       };
88168     }
88169   }
88170
88171   jresult = (void *)result;
88172   return jresult;
88173 }
88174
88175
88176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
88177   void * jresult ;
88178   Dali::BaseHandle arg1 ;
88179   Dali::BaseHandle *argp1 ;
88180   Dali::Toolkit::Popup result;
88181
88182   argp1 = (Dali::BaseHandle *)jarg1;
88183   if (!argp1) {
88184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88185     return 0;
88186   }
88187   arg1 = *argp1;
88188   {
88189     try {
88190       result = Dali::Toolkit::Popup::DownCast(arg1);
88191     } catch (std::out_of_range& e) {
88192       {
88193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88194       };
88195     } catch (std::exception& e) {
88196       {
88197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88198       };
88199     } catch (Dali::DaliException e) {
88200       {
88201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88202       };
88203     } catch (...) {
88204       {
88205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88206       };
88207     }
88208   }
88209
88210   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
88211   return jresult;
88212 }
88213
88214
88215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
88216   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88217   Dali::Actor arg2 ;
88218   Dali::Actor *argp2 ;
88219
88220   arg1 = (Dali::Toolkit::Popup *)jarg1;
88221   argp2 = (Dali::Actor *)jarg2;
88222   if (!argp2) {
88223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88224     return ;
88225   }
88226   arg2 = *argp2;
88227   {
88228     try {
88229       (arg1)->SetTitle(arg2);
88230     } catch (std::out_of_range& e) {
88231       {
88232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88233       };
88234     } catch (std::exception& e) {
88235       {
88236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88237       };
88238     } catch (Dali::DaliException e) {
88239       {
88240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88241       };
88242     } catch (...) {
88243       {
88244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88245       };
88246     }
88247   }
88248
88249 }
88250
88251
88252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
88253   void * jresult ;
88254   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88255   Dali::Actor result;
88256
88257   arg1 = (Dali::Toolkit::Popup *)jarg1;
88258   {
88259     try {
88260       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
88261     } catch (std::out_of_range& e) {
88262       {
88263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88264       };
88265     } catch (std::exception& e) {
88266       {
88267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88268       };
88269     } catch (Dali::DaliException e) {
88270       {
88271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88272       };
88273     } catch (...) {
88274       {
88275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88276       };
88277     }
88278   }
88279
88280   jresult = new Dali::Actor((const Dali::Actor &)result);
88281   return jresult;
88282 }
88283
88284
88285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
88286   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88287   Dali::Actor arg2 ;
88288   Dali::Actor *argp2 ;
88289
88290   arg1 = (Dali::Toolkit::Popup *)jarg1;
88291   argp2 = (Dali::Actor *)jarg2;
88292   if (!argp2) {
88293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88294     return ;
88295   }
88296   arg2 = *argp2;
88297   {
88298     try {
88299       (arg1)->SetContent(arg2);
88300     } catch (std::out_of_range& e) {
88301       {
88302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88303       };
88304     } catch (std::exception& e) {
88305       {
88306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88307       };
88308     } catch (Dali::DaliException e) {
88309       {
88310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88311       };
88312     } catch (...) {
88313       {
88314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88315       };
88316     }
88317   }
88318
88319 }
88320
88321
88322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
88323   void * jresult ;
88324   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88325   Dali::Actor result;
88326
88327   arg1 = (Dali::Toolkit::Popup *)jarg1;
88328   {
88329     try {
88330       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
88331     } catch (std::out_of_range& e) {
88332       {
88333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88334       };
88335     } catch (std::exception& e) {
88336       {
88337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88338       };
88339     } catch (Dali::DaliException e) {
88340       {
88341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88342       };
88343     } catch (...) {
88344       {
88345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88346       };
88347     }
88348   }
88349
88350   jresult = new Dali::Actor((const Dali::Actor &)result);
88351   return jresult;
88352 }
88353
88354
88355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
88356   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88357   Dali::Actor arg2 ;
88358   Dali::Actor *argp2 ;
88359
88360   arg1 = (Dali::Toolkit::Popup *)jarg1;
88361   argp2 = (Dali::Actor *)jarg2;
88362   if (!argp2) {
88363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88364     return ;
88365   }
88366   arg2 = *argp2;
88367   {
88368     try {
88369       (arg1)->SetFooter(arg2);
88370     } catch (std::out_of_range& e) {
88371       {
88372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88373       };
88374     } catch (std::exception& e) {
88375       {
88376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88377       };
88378     } catch (Dali::DaliException e) {
88379       {
88380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88381       };
88382     } catch (...) {
88383       {
88384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88385       };
88386     }
88387   }
88388
88389 }
88390
88391
88392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
88393   void * jresult ;
88394   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88395   Dali::Actor result;
88396
88397   arg1 = (Dali::Toolkit::Popup *)jarg1;
88398   {
88399     try {
88400       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
88401     } catch (std::out_of_range& e) {
88402       {
88403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88404       };
88405     } catch (std::exception& e) {
88406       {
88407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88408       };
88409     } catch (Dali::DaliException e) {
88410       {
88411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88412       };
88413     } catch (...) {
88414       {
88415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88416       };
88417     }
88418   }
88419
88420   jresult = new Dali::Actor((const Dali::Actor &)result);
88421   return jresult;
88422 }
88423
88424
88425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
88426   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88427   Dali::Toolkit::Popup::DisplayState arg2 ;
88428
88429   arg1 = (Dali::Toolkit::Popup *)jarg1;
88430   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
88431   {
88432     try {
88433       (arg1)->SetDisplayState(arg2);
88434     } catch (std::out_of_range& e) {
88435       {
88436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88437       };
88438     } catch (std::exception& e) {
88439       {
88440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88441       };
88442     } catch (Dali::DaliException e) {
88443       {
88444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88445       };
88446     } catch (...) {
88447       {
88448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88449       };
88450     }
88451   }
88452
88453 }
88454
88455
88456 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
88457   int jresult ;
88458   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88459   Dali::Toolkit::Popup::DisplayState result;
88460
88461   arg1 = (Dali::Toolkit::Popup *)jarg1;
88462   {
88463     try {
88464       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
88465     } catch (std::out_of_range& e) {
88466       {
88467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88468       };
88469     } catch (std::exception& e) {
88470       {
88471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88472       };
88473     } catch (Dali::DaliException e) {
88474       {
88475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88476       };
88477     } catch (...) {
88478       {
88479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88480       };
88481     }
88482   }
88483
88484   jresult = (int)result;
88485   return jresult;
88486 }
88487
88488
88489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
88490   void * jresult ;
88491   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88492   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
88493
88494   arg1 = (Dali::Toolkit::Popup *)jarg1;
88495   {
88496     try {
88497       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
88498     } catch (std::out_of_range& e) {
88499       {
88500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88501       };
88502     } catch (std::exception& e) {
88503       {
88504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88505       };
88506     } catch (Dali::DaliException e) {
88507       {
88508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88509       };
88510     } catch (...) {
88511       {
88512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88513       };
88514     }
88515   }
88516
88517   jresult = (void *)result;
88518   return jresult;
88519 }
88520
88521
88522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
88523   void * jresult ;
88524   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88525   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88526
88527   arg1 = (Dali::Toolkit::Popup *)jarg1;
88528   {
88529     try {
88530       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
88531     } catch (std::out_of_range& e) {
88532       {
88533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88534       };
88535     } catch (std::exception& e) {
88536       {
88537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88538       };
88539     } catch (Dali::DaliException e) {
88540       {
88541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88542       };
88543     } catch (...) {
88544       {
88545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88546       };
88547     }
88548   }
88549
88550   jresult = (void *)result;
88551   return jresult;
88552 }
88553
88554
88555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
88556   void * jresult ;
88557   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88558   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88559
88560   arg1 = (Dali::Toolkit::Popup *)jarg1;
88561   {
88562     try {
88563       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
88564     } catch (std::out_of_range& e) {
88565       {
88566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88567       };
88568     } catch (std::exception& e) {
88569       {
88570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88571       };
88572     } catch (Dali::DaliException e) {
88573       {
88574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88575       };
88576     } catch (...) {
88577       {
88578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88579       };
88580     }
88581   }
88582
88583   jresult = (void *)result;
88584   return jresult;
88585 }
88586
88587
88588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
88589   void * jresult ;
88590   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88591   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88592
88593   arg1 = (Dali::Toolkit::Popup *)jarg1;
88594   {
88595     try {
88596       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
88597     } catch (std::out_of_range& e) {
88598       {
88599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88600       };
88601     } catch (std::exception& e) {
88602       {
88603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88604       };
88605     } catch (Dali::DaliException e) {
88606       {
88607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88608       };
88609     } catch (...) {
88610       {
88611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88612       };
88613     }
88614   }
88615
88616   jresult = (void *)result;
88617   return jresult;
88618 }
88619
88620
88621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
88622   void * jresult ;
88623   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88624   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88625
88626   arg1 = (Dali::Toolkit::Popup *)jarg1;
88627   {
88628     try {
88629       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
88630     } catch (std::out_of_range& e) {
88631       {
88632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88633       };
88634     } catch (std::exception& e) {
88635       {
88636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88637       };
88638     } catch (Dali::DaliException e) {
88639       {
88640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88641       };
88642     } catch (...) {
88643       {
88644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88645       };
88646     }
88647   }
88648
88649   jresult = (void *)result;
88650   return jresult;
88651 }
88652
88653
88654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
88655   int jresult ;
88656   int result;
88657
88658   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
88659   jresult = (int)result;
88660   return jresult;
88661 }
88662
88663
88664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
88665   int jresult ;
88666   int result;
88667
88668   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
88669   jresult = (int)result;
88670   return jresult;
88671 }
88672
88673
88674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
88675   int jresult ;
88676   int result;
88677
88678   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
88679   jresult = (int)result;
88680   return jresult;
88681 }
88682
88683
88684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
88685   int jresult ;
88686   int result;
88687
88688   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
88689   jresult = (int)result;
88690   return jresult;
88691 }
88692
88693
88694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
88695   int jresult ;
88696   int result;
88697
88698   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
88699   jresult = (int)result;
88700   return jresult;
88701 }
88702
88703
88704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
88705   int jresult ;
88706   int result;
88707
88708   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
88709   jresult = (int)result;
88710   return jresult;
88711 }
88712
88713
88714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
88715   int jresult ;
88716   int result;
88717
88718   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
88719   jresult = (int)result;
88720   return jresult;
88721 }
88722
88723
88724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
88725   int jresult ;
88726   int result;
88727
88728   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
88729   jresult = (int)result;
88730   return jresult;
88731 }
88732
88733
88734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
88735   int jresult ;
88736   int result;
88737
88738   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
88739   jresult = (int)result;
88740   return jresult;
88741 }
88742
88743
88744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
88745   void * jresult ;
88746   Dali::Toolkit::ProgressBar::Property *result = 0 ;
88747
88748   {
88749     try {
88750       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
88751     } catch (std::out_of_range& e) {
88752       {
88753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88754       };
88755     } catch (std::exception& e) {
88756       {
88757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88758       };
88759     } catch (Dali::DaliException e) {
88760       {
88761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88762       };
88763     } catch (...) {
88764       {
88765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88766       };
88767     }
88768   }
88769
88770   jresult = (void *)result;
88771   return jresult;
88772 }
88773
88774
88775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
88776   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
88777
88778   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
88779   {
88780     try {
88781       delete arg1;
88782     } catch (std::out_of_range& e) {
88783       {
88784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88785       };
88786     } catch (std::exception& e) {
88787       {
88788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88789       };
88790     } catch (Dali::DaliException e) {
88791       {
88792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88793       };
88794     } catch (...) {
88795       {
88796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88797       };
88798     }
88799   }
88800
88801 }
88802
88803
88804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
88805   void * jresult ;
88806   Dali::Toolkit::ProgressBar result;
88807
88808   {
88809     try {
88810       result = Dali::Toolkit::ProgressBar::New();
88811     } catch (std::out_of_range& e) {
88812       {
88813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88814       };
88815     } catch (std::exception& e) {
88816       {
88817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88818       };
88819     } catch (Dali::DaliException e) {
88820       {
88821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88822       };
88823     } catch (...) {
88824       {
88825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88826       };
88827     }
88828   }
88829
88830   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
88831   return jresult;
88832 }
88833
88834
88835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
88836   void * jresult ;
88837   Dali::Toolkit::ProgressBar *result = 0 ;
88838
88839   {
88840     try {
88841       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
88842     } catch (std::out_of_range& e) {
88843       {
88844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88845       };
88846     } catch (std::exception& e) {
88847       {
88848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88849       };
88850     } catch (Dali::DaliException e) {
88851       {
88852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88853       };
88854     } catch (...) {
88855       {
88856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88857       };
88858     }
88859   }
88860
88861   jresult = (void *)result;
88862   return jresult;
88863 }
88864
88865
88866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
88867   void * jresult ;
88868   Dali::Toolkit::ProgressBar *arg1 = 0 ;
88869   Dali::Toolkit::ProgressBar *result = 0 ;
88870
88871   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88872   if (!arg1) {
88873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
88874     return 0;
88875   }
88876   {
88877     try {
88878       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
88879     } catch (std::out_of_range& e) {
88880       {
88881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88882       };
88883     } catch (std::exception& e) {
88884       {
88885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88886       };
88887     } catch (Dali::DaliException e) {
88888       {
88889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88890       };
88891     } catch (...) {
88892       {
88893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88894       };
88895     }
88896   }
88897
88898   jresult = (void *)result;
88899   return jresult;
88900 }
88901
88902
88903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
88904   void * jresult ;
88905   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
88906   Dali::Toolkit::ProgressBar *arg2 = 0 ;
88907   Dali::Toolkit::ProgressBar *result = 0 ;
88908
88909   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88910   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
88911   if (!arg2) {
88912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
88913     return 0;
88914   }
88915   {
88916     try {
88917       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
88918     } catch (std::out_of_range& e) {
88919       {
88920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88921       };
88922     } catch (std::exception& e) {
88923       {
88924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88925       };
88926     } catch (Dali::DaliException e) {
88927       {
88928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88929       };
88930     } catch (...) {
88931       {
88932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88933       };
88934     }
88935   }
88936
88937   jresult = (void *)result;
88938   return jresult;
88939 }
88940
88941
88942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
88943   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
88944
88945   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88946   {
88947     try {
88948       delete arg1;
88949     } catch (std::out_of_range& e) {
88950       {
88951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88952       };
88953     } catch (std::exception& e) {
88954       {
88955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88956       };
88957     } catch (Dali::DaliException e) {
88958       {
88959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88960       };
88961     } catch (...) {
88962       {
88963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88964       };
88965     }
88966   }
88967
88968 }
88969
88970
88971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
88972   void * jresult ;
88973   Dali::BaseHandle arg1 ;
88974   Dali::BaseHandle *argp1 ;
88975   Dali::Toolkit::ProgressBar result;
88976
88977   argp1 = (Dali::BaseHandle *)jarg1;
88978   if (!argp1) {
88979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88980     return 0;
88981   }
88982   arg1 = *argp1;
88983   {
88984     try {
88985       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
88986     } catch (std::out_of_range& e) {
88987       {
88988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88989       };
88990     } catch (std::exception& e) {
88991       {
88992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88993       };
88994     } catch (Dali::DaliException e) {
88995       {
88996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88997       };
88998     } catch (...) {
88999       {
89000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89001       };
89002     }
89003   }
89004
89005   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
89006   return jresult;
89007 }
89008
89009
89010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
89011   void * jresult ;
89012   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89013   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
89014
89015   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89016   {
89017     try {
89018       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
89019     } catch (std::out_of_range& e) {
89020       {
89021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89022       };
89023     } catch (std::exception& e) {
89024       {
89025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89026       };
89027     } catch (Dali::DaliException e) {
89028       {
89029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89030       };
89031     } catch (...) {
89032       {
89033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89034       };
89035     }
89036   }
89037
89038   jresult = (void *)result;
89039   return jresult;
89040 }
89041
89042
89043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
89044   void * jresult ;
89045   Dali::Toolkit::GaussianBlurView *result = 0 ;
89046
89047   {
89048     try {
89049       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
89050     } catch (std::out_of_range& e) {
89051       {
89052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89053       };
89054     } catch (std::exception& e) {
89055       {
89056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89057       };
89058     } catch (Dali::DaliException e) {
89059       {
89060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89061       };
89062     } catch (...) {
89063       {
89064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89065       };
89066     }
89067   }
89068
89069   jresult = (void *)result;
89070   return jresult;
89071 }
89072
89073
89074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
89075   void * jresult ;
89076   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
89077   Dali::Toolkit::GaussianBlurView *result = 0 ;
89078
89079   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89080   if (!arg1) {
89081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
89082     return 0;
89083   }
89084   {
89085     try {
89086       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
89087     } catch (std::out_of_range& e) {
89088       {
89089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89090       };
89091     } catch (std::exception& e) {
89092       {
89093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89094       };
89095     } catch (Dali::DaliException e) {
89096       {
89097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89098       };
89099     } catch (...) {
89100       {
89101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89102       };
89103     }
89104   }
89105
89106   jresult = (void *)result;
89107   return jresult;
89108 }
89109
89110
89111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
89112   void * jresult ;
89113   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89114   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
89115   Dali::Toolkit::GaussianBlurView *result = 0 ;
89116
89117   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89118   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
89119   if (!arg2) {
89120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
89121     return 0;
89122   }
89123   {
89124     try {
89125       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
89126     } catch (std::out_of_range& e) {
89127       {
89128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89129       };
89130     } catch (std::exception& e) {
89131       {
89132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89133       };
89134     } catch (Dali::DaliException e) {
89135       {
89136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89137       };
89138     } catch (...) {
89139       {
89140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89141       };
89142     }
89143   }
89144
89145   jresult = (void *)result;
89146   return jresult;
89147 }
89148
89149
89150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
89151   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89152
89153   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89154   {
89155     try {
89156       delete arg1;
89157     } catch (std::out_of_range& e) {
89158       {
89159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89160       };
89161     } catch (std::exception& e) {
89162       {
89163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89164       };
89165     } catch (Dali::DaliException e) {
89166       {
89167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89168       };
89169     } catch (...) {
89170       {
89171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89172       };
89173     }
89174   }
89175
89176 }
89177
89178
89179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
89180   void * jresult ;
89181   Dali::BaseHandle arg1 ;
89182   Dali::BaseHandle *argp1 ;
89183   Dali::Toolkit::GaussianBlurView result;
89184
89185   argp1 = (Dali::BaseHandle *)jarg1;
89186   if (!argp1) {
89187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89188     return 0;
89189   }
89190   arg1 = *argp1;
89191   {
89192     try {
89193       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
89194     } catch (std::out_of_range& e) {
89195       {
89196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89197       };
89198     } catch (std::exception& e) {
89199       {
89200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89201       };
89202     } catch (Dali::DaliException e) {
89203       {
89204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89205       };
89206     } catch (...) {
89207       {
89208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89209       };
89210     }
89211   }
89212
89213   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89214   return jresult;
89215 }
89216
89217
89218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
89219   void * jresult ;
89220   Dali::Toolkit::GaussianBlurView result;
89221
89222   {
89223     try {
89224       result = Dali::Toolkit::GaussianBlurView::New();
89225     } catch (std::out_of_range& e) {
89226       {
89227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89228       };
89229     } catch (std::exception& e) {
89230       {
89231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89232       };
89233     } catch (Dali::DaliException e) {
89234       {
89235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89236       };
89237     } catch (...) {
89238       {
89239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89240       };
89241     }
89242   }
89243
89244   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89245   return jresult;
89246 }
89247
89248
89249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
89250   void * jresult ;
89251   unsigned int arg1 ;
89252   float arg2 ;
89253   Dali::Pixel::Format arg3 ;
89254   float arg4 ;
89255   float arg5 ;
89256   bool arg6 ;
89257   Dali::Toolkit::GaussianBlurView result;
89258
89259   arg1 = (unsigned int)jarg1;
89260   arg2 = (float)jarg2;
89261   arg3 = (Dali::Pixel::Format)jarg3;
89262   arg4 = (float)jarg4;
89263   arg5 = (float)jarg5;
89264   arg6 = jarg6 ? true : false;
89265   {
89266     try {
89267       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
89268     } catch (std::out_of_range& e) {
89269       {
89270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89271       };
89272     } catch (std::exception& e) {
89273       {
89274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89275       };
89276     } catch (Dali::DaliException e) {
89277       {
89278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89279       };
89280     } catch (...) {
89281       {
89282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89283       };
89284     }
89285   }
89286
89287   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89288   return jresult;
89289 }
89290
89291
89292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
89293   void * jresult ;
89294   unsigned int arg1 ;
89295   float arg2 ;
89296   Dali::Pixel::Format arg3 ;
89297   float arg4 ;
89298   float arg5 ;
89299   Dali::Toolkit::GaussianBlurView result;
89300
89301   arg1 = (unsigned int)jarg1;
89302   arg2 = (float)jarg2;
89303   arg3 = (Dali::Pixel::Format)jarg3;
89304   arg4 = (float)jarg4;
89305   arg5 = (float)jarg5;
89306   {
89307     try {
89308       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
89309     } catch (std::out_of_range& e) {
89310       {
89311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89312       };
89313     } catch (std::exception& e) {
89314       {
89315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89316       };
89317     } catch (Dali::DaliException e) {
89318       {
89319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89320       };
89321     } catch (...) {
89322       {
89323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89324       };
89325     }
89326   }
89327
89328   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89329   return jresult;
89330 }
89331
89332
89333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
89334   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89335   Dali::Actor arg2 ;
89336   Dali::Actor *argp2 ;
89337
89338   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89339   argp2 = (Dali::Actor *)jarg2;
89340   if (!argp2) {
89341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89342     return ;
89343   }
89344   arg2 = *argp2;
89345   {
89346     try {
89347       (arg1)->Add(arg2);
89348     } catch (std::out_of_range& e) {
89349       {
89350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89351       };
89352     } catch (std::exception& e) {
89353       {
89354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89355       };
89356     } catch (Dali::DaliException e) {
89357       {
89358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89359       };
89360     } catch (...) {
89361       {
89362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89363       };
89364     }
89365   }
89366
89367 }
89368
89369
89370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
89371   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89372   Dali::Actor arg2 ;
89373   Dali::Actor *argp2 ;
89374
89375   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89376   argp2 = (Dali::Actor *)jarg2;
89377   if (!argp2) {
89378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89379     return ;
89380   }
89381   arg2 = *argp2;
89382   {
89383     try {
89384       (arg1)->Remove(arg2);
89385     } catch (std::out_of_range& e) {
89386       {
89387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89388       };
89389     } catch (std::exception& e) {
89390       {
89391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89392       };
89393     } catch (Dali::DaliException e) {
89394       {
89395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89396       };
89397     } catch (...) {
89398       {
89399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89400       };
89401     }
89402   }
89403
89404 }
89405
89406
89407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
89408   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89409
89410   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89411   {
89412     try {
89413       (arg1)->Activate();
89414     } catch (std::out_of_range& e) {
89415       {
89416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89417       };
89418     } catch (std::exception& e) {
89419       {
89420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89421       };
89422     } catch (Dali::DaliException e) {
89423       {
89424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89425       };
89426     } catch (...) {
89427       {
89428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89429       };
89430     }
89431   }
89432
89433 }
89434
89435
89436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
89437   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89438
89439   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89440   {
89441     try {
89442       (arg1)->ActivateOnce();
89443     } catch (std::out_of_range& e) {
89444       {
89445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89446       };
89447     } catch (std::exception& e) {
89448       {
89449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89450       };
89451     } catch (Dali::DaliException e) {
89452       {
89453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89454       };
89455     } catch (...) {
89456       {
89457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89458       };
89459     }
89460   }
89461
89462 }
89463
89464
89465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
89466   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89467
89468   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89469   {
89470     try {
89471       (arg1)->Deactivate();
89472     } catch (std::out_of_range& e) {
89473       {
89474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89475       };
89476     } catch (std::exception& e) {
89477       {
89478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89479       };
89480     } catch (Dali::DaliException e) {
89481       {
89482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89483       };
89484     } catch (...) {
89485       {
89486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89487       };
89488     }
89489   }
89490
89491 }
89492
89493
89494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
89495   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89496   Dali::Image arg2 ;
89497   Dali::FrameBufferImage arg3 ;
89498   Dali::Image *argp2 ;
89499   Dali::FrameBufferImage *argp3 ;
89500
89501   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89502   argp2 = (Dali::Image *)jarg2;
89503   if (!argp2) {
89504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
89505     return ;
89506   }
89507   arg2 = *argp2;
89508   argp3 = (Dali::FrameBufferImage *)jarg3;
89509   if (!argp3) {
89510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
89511     return ;
89512   }
89513   arg3 = *argp3;
89514   {
89515     try {
89516       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
89517     } catch (std::out_of_range& e) {
89518       {
89519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89520       };
89521     } catch (std::exception& e) {
89522       {
89523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89524       };
89525     } catch (Dali::DaliException e) {
89526       {
89527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89528       };
89529     } catch (...) {
89530       {
89531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89532       };
89533     }
89534   }
89535
89536 }
89537
89538
89539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
89540   int jresult ;
89541   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89542   Dali::Property::Index result;
89543
89544   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89545   {
89546     try {
89547       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
89548     } catch (std::out_of_range& e) {
89549       {
89550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89551       };
89552     } catch (std::exception& e) {
89553       {
89554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89555       };
89556     } catch (Dali::DaliException e) {
89557       {
89558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89559       };
89560     } catch (...) {
89561       {
89562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89563       };
89564     }
89565   }
89566
89567   jresult = result;
89568   return jresult;
89569 }
89570
89571
89572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
89573   void * jresult ;
89574   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89575   Dali::FrameBufferImage result;
89576
89577   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89578   {
89579     try {
89580       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
89581     } catch (std::out_of_range& e) {
89582       {
89583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89584       };
89585     } catch (std::exception& e) {
89586       {
89587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89588       };
89589     } catch (Dali::DaliException e) {
89590       {
89591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89592       };
89593     } catch (...) {
89594       {
89595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89596       };
89597     }
89598   }
89599
89600   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
89601   return jresult;
89602 }
89603
89604
89605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
89606   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89607   Dali::Vector4 *arg2 = 0 ;
89608
89609   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89610   arg2 = (Dali::Vector4 *)jarg2;
89611   if (!arg2) {
89612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
89613     return ;
89614   }
89615   {
89616     try {
89617       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
89618     } catch (std::out_of_range& e) {
89619       {
89620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89621       };
89622     } catch (std::exception& e) {
89623       {
89624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89625       };
89626     } catch (Dali::DaliException e) {
89627       {
89628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89629       };
89630     } catch (...) {
89631       {
89632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89633       };
89634     }
89635   }
89636
89637 }
89638
89639
89640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
89641   void * jresult ;
89642   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89643   Dali::Vector4 result;
89644
89645   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89646   {
89647     try {
89648       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
89649     } catch (std::out_of_range& e) {
89650       {
89651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89652       };
89653     } catch (std::exception& e) {
89654       {
89655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89656       };
89657     } catch (Dali::DaliException e) {
89658       {
89659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89660       };
89661     } catch (...) {
89662       {
89663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89664       };
89665     }
89666   }
89667
89668   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
89669   return jresult;
89670 }
89671
89672
89673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
89674   void * jresult ;
89675   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89676   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
89677
89678   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89679   {
89680     try {
89681       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
89682     } catch (std::out_of_range& e) {
89683       {
89684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89685       };
89686     } catch (std::exception& e) {
89687       {
89688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89689       };
89690     } catch (Dali::DaliException e) {
89691       {
89692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89693       };
89694     } catch (...) {
89695       {
89696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89697       };
89698     }
89699   }
89700
89701   jresult = (void *)result;
89702   return jresult;
89703 }
89704
89705
89706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
89707   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89708
89709   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89710   {
89711     try {
89712       delete arg1;
89713     } catch (std::out_of_range& e) {
89714       {
89715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89716       };
89717     } catch (std::exception& e) {
89718       {
89719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89720       };
89721     } catch (Dali::DaliException e) {
89722       {
89723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89724       };
89725     } catch (...) {
89726       {
89727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89728       };
89729     }
89730   }
89731
89732 }
89733
89734
89735 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
89736   unsigned int jresult ;
89737   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89738   unsigned int result;
89739
89740   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89741   {
89742     try {
89743       result = (unsigned int)(arg1)->GetNumberOfPages();
89744     } catch (std::out_of_range& e) {
89745       {
89746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89747       };
89748     } catch (std::exception& e) {
89749       {
89750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89751       };
89752     } catch (Dali::DaliException e) {
89753       {
89754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89755       };
89756     } catch (...) {
89757       {
89758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89759       };
89760     }
89761   }
89762
89763   jresult = result;
89764   return jresult;
89765 }
89766
89767
89768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
89769   void * jresult ;
89770   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89771   unsigned int arg2 ;
89772   Dali::Texture result;
89773
89774   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89775   arg2 = (unsigned int)jarg2;
89776   {
89777     try {
89778       result = (arg1)->NewPage(arg2);
89779     } catch (std::out_of_range& e) {
89780       {
89781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89782       };
89783     } catch (std::exception& e) {
89784       {
89785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89786       };
89787     } catch (Dali::DaliException e) {
89788       {
89789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89790       };
89791     } catch (...) {
89792       {
89793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89794       };
89795     }
89796   }
89797
89798   jresult = new Dali::Texture((const Dali::Texture &)result);
89799   return jresult;
89800 }
89801
89802
89803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
89804   int jresult ;
89805   int result;
89806
89807   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
89808   jresult = (int)result;
89809   return jresult;
89810 }
89811
89812
89813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
89814   int jresult ;
89815   int result;
89816
89817   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
89818   jresult = (int)result;
89819   return jresult;
89820 }
89821
89822
89823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
89824   int jresult ;
89825   int result;
89826
89827   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
89828   jresult = (int)result;
89829   return jresult;
89830 }
89831
89832
89833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
89834   void * jresult ;
89835   Dali::Toolkit::PageTurnView::Property *result = 0 ;
89836
89837   {
89838     try {
89839       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
89840     } catch (std::out_of_range& e) {
89841       {
89842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89843       };
89844     } catch (std::exception& e) {
89845       {
89846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89847       };
89848     } catch (Dali::DaliException e) {
89849       {
89850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89851       };
89852     } catch (...) {
89853       {
89854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89855       };
89856     }
89857   }
89858
89859   jresult = (void *)result;
89860   return jresult;
89861 }
89862
89863
89864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
89865   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
89866
89867   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
89868   {
89869     try {
89870       delete arg1;
89871     } catch (std::out_of_range& e) {
89872       {
89873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89874       };
89875     } catch (std::exception& e) {
89876       {
89877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89878       };
89879     } catch (Dali::DaliException e) {
89880       {
89881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89882       };
89883     } catch (...) {
89884       {
89885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89886       };
89887     }
89888   }
89889
89890 }
89891
89892
89893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
89894   void * jresult ;
89895   Dali::Toolkit::PageTurnView *result = 0 ;
89896
89897   {
89898     try {
89899       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
89900     } catch (std::out_of_range& e) {
89901       {
89902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89903       };
89904     } catch (std::exception& e) {
89905       {
89906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89907       };
89908     } catch (Dali::DaliException e) {
89909       {
89910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89911       };
89912     } catch (...) {
89913       {
89914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89915       };
89916     }
89917   }
89918
89919   jresult = (void *)result;
89920   return jresult;
89921 }
89922
89923
89924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
89925   void * jresult ;
89926   Dali::Toolkit::PageTurnView *arg1 = 0 ;
89927   Dali::Toolkit::PageTurnView *result = 0 ;
89928
89929   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89930   if (!arg1) {
89931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
89932     return 0;
89933   }
89934   {
89935     try {
89936       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
89937     } catch (std::out_of_range& e) {
89938       {
89939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89940       };
89941     } catch (std::exception& e) {
89942       {
89943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89944       };
89945     } catch (Dali::DaliException e) {
89946       {
89947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89948       };
89949     } catch (...) {
89950       {
89951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89952       };
89953     }
89954   }
89955
89956   jresult = (void *)result;
89957   return jresult;
89958 }
89959
89960
89961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
89962   void * jresult ;
89963   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89964   Dali::Toolkit::PageTurnView *arg2 = 0 ;
89965   Dali::Toolkit::PageTurnView *result = 0 ;
89966
89967   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89968   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
89969   if (!arg2) {
89970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
89971     return 0;
89972   }
89973   {
89974     try {
89975       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
89976     } catch (std::out_of_range& e) {
89977       {
89978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89979       };
89980     } catch (std::exception& e) {
89981       {
89982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89983       };
89984     } catch (Dali::DaliException e) {
89985       {
89986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89987       };
89988     } catch (...) {
89989       {
89990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89991       };
89992     }
89993   }
89994
89995   jresult = (void *)result;
89996   return jresult;
89997 }
89998
89999
90000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
90001   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90002
90003   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90004   {
90005     try {
90006       delete arg1;
90007     } catch (std::out_of_range& e) {
90008       {
90009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90010       };
90011     } catch (std::exception& e) {
90012       {
90013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90014       };
90015     } catch (Dali::DaliException e) {
90016       {
90017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90018       };
90019     } catch (...) {
90020       {
90021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90022       };
90023     }
90024   }
90025
90026 }
90027
90028
90029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
90030   void * jresult ;
90031   Dali::BaseHandle arg1 ;
90032   Dali::BaseHandle *argp1 ;
90033   Dali::Toolkit::PageTurnView result;
90034
90035   argp1 = (Dali::BaseHandle *)jarg1;
90036   if (!argp1) {
90037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90038     return 0;
90039   }
90040   arg1 = *argp1;
90041   {
90042     try {
90043       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
90044     } catch (std::out_of_range& e) {
90045       {
90046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90047       };
90048     } catch (std::exception& e) {
90049       {
90050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90051       };
90052     } catch (Dali::DaliException e) {
90053       {
90054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90055       };
90056     } catch (...) {
90057       {
90058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90059       };
90060     }
90061   }
90062
90063   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
90064   return jresult;
90065 }
90066
90067
90068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
90069   void * jresult ;
90070   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90071   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
90072
90073   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90074   {
90075     try {
90076       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
90077     } catch (std::out_of_range& e) {
90078       {
90079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90080       };
90081     } catch (std::exception& e) {
90082       {
90083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90084       };
90085     } catch (Dali::DaliException e) {
90086       {
90087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90088       };
90089     } catch (...) {
90090       {
90091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90092       };
90093     }
90094   }
90095
90096   jresult = (void *)result;
90097   return jresult;
90098 }
90099
90100
90101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
90102   void * jresult ;
90103   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90104   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
90105
90106   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90107   {
90108     try {
90109       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
90110     } catch (std::out_of_range& e) {
90111       {
90112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90113       };
90114     } catch (std::exception& e) {
90115       {
90116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90117       };
90118     } catch (Dali::DaliException e) {
90119       {
90120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90121       };
90122     } catch (...) {
90123       {
90124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90125       };
90126     }
90127   }
90128
90129   jresult = (void *)result;
90130   return jresult;
90131 }
90132
90133
90134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
90135   void * jresult ;
90136   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90137   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
90138
90139   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90140   {
90141     try {
90142       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
90143     } catch (std::out_of_range& e) {
90144       {
90145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90146       };
90147     } catch (std::exception& e) {
90148       {
90149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90150       };
90151     } catch (Dali::DaliException e) {
90152       {
90153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90154       };
90155     } catch (...) {
90156       {
90157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90158       };
90159     }
90160   }
90161
90162   jresult = (void *)result;
90163   return jresult;
90164 }
90165
90166
90167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
90168   void * jresult ;
90169   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90170   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
90171
90172   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90173   {
90174     try {
90175       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
90176     } catch (std::out_of_range& e) {
90177       {
90178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90179       };
90180     } catch (std::exception& e) {
90181       {
90182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90183       };
90184     } catch (Dali::DaliException e) {
90185       {
90186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90187       };
90188     } catch (...) {
90189       {
90190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90191       };
90192     }
90193   }
90194
90195   jresult = (void *)result;
90196   return jresult;
90197 }
90198
90199
90200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
90201   void * jresult ;
90202   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90203
90204   {
90205     try {
90206       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
90207     } catch (std::out_of_range& e) {
90208       {
90209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90210       };
90211     } catch (std::exception& e) {
90212       {
90213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90214       };
90215     } catch (Dali::DaliException e) {
90216       {
90217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90218       };
90219     } catch (...) {
90220       {
90221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90222       };
90223     }
90224   }
90225
90226   jresult = (void *)result;
90227   return jresult;
90228 }
90229
90230
90231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
90232   void * jresult ;
90233   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
90234   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90235
90236   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90237   if (!arg1) {
90238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90239     return 0;
90240   }
90241   {
90242     try {
90243       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
90244     } catch (std::out_of_range& e) {
90245       {
90246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90247       };
90248     } catch (std::exception& e) {
90249       {
90250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90251       };
90252     } catch (Dali::DaliException e) {
90253       {
90254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90255       };
90256     } catch (...) {
90257       {
90258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90259       };
90260     }
90261   }
90262
90263   jresult = (void *)result;
90264   return jresult;
90265 }
90266
90267
90268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
90269   void * jresult ;
90270   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90271   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
90272   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90273
90274   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90275   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
90276   if (!arg2) {
90277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90278     return 0;
90279   }
90280   {
90281     try {
90282       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
90283     } catch (std::out_of_range& e) {
90284       {
90285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90286       };
90287     } catch (std::exception& e) {
90288       {
90289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90290       };
90291     } catch (Dali::DaliException e) {
90292       {
90293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90294       };
90295     } catch (...) {
90296       {
90297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90298       };
90299     }
90300   }
90301
90302   jresult = (void *)result;
90303   return jresult;
90304 }
90305
90306
90307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
90308   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90309
90310   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90311   {
90312     try {
90313       delete arg1;
90314     } catch (std::out_of_range& e) {
90315       {
90316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90317       };
90318     } catch (std::exception& e) {
90319       {
90320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90321       };
90322     } catch (Dali::DaliException e) {
90323       {
90324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90325       };
90326     } catch (...) {
90327       {
90328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90329       };
90330     }
90331   }
90332
90333 }
90334
90335
90336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
90337   void * jresult ;
90338   Dali::Toolkit::PageFactory *arg1 = 0 ;
90339   Dali::Vector2 *arg2 = 0 ;
90340   Dali::Toolkit::PageTurnLandscapeView result;
90341
90342   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90343   if (!arg1) {
90344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90345     return 0;
90346   }
90347   arg2 = (Dali::Vector2 *)jarg2;
90348   if (!arg2) {
90349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90350     return 0;
90351   }
90352   {
90353     try {
90354       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
90355     } catch (std::out_of_range& e) {
90356       {
90357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90358       };
90359     } catch (std::exception& e) {
90360       {
90361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90362       };
90363     } catch (Dali::DaliException e) {
90364       {
90365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90366       };
90367     } catch (...) {
90368       {
90369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90370       };
90371     }
90372   }
90373
90374   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90375   return jresult;
90376 }
90377
90378
90379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
90380   void * jresult ;
90381   Dali::BaseHandle arg1 ;
90382   Dali::BaseHandle *argp1 ;
90383   Dali::Toolkit::PageTurnLandscapeView result;
90384
90385   argp1 = (Dali::BaseHandle *)jarg1;
90386   if (!argp1) {
90387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90388     return 0;
90389   }
90390   arg1 = *argp1;
90391   {
90392     try {
90393       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
90394     } catch (std::out_of_range& e) {
90395       {
90396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90397       };
90398     } catch (std::exception& e) {
90399       {
90400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90401       };
90402     } catch (Dali::DaliException e) {
90403       {
90404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90405       };
90406     } catch (...) {
90407       {
90408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90409       };
90410     }
90411   }
90412
90413   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90414   return jresult;
90415 }
90416
90417
90418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
90419   void * jresult ;
90420   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90421
90422   {
90423     try {
90424       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
90425     } catch (std::out_of_range& e) {
90426       {
90427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90428       };
90429     } catch (std::exception& e) {
90430       {
90431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90432       };
90433     } catch (Dali::DaliException e) {
90434       {
90435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90436       };
90437     } catch (...) {
90438       {
90439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90440       };
90441     }
90442   }
90443
90444   jresult = (void *)result;
90445   return jresult;
90446 }
90447
90448
90449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
90450   void * jresult ;
90451   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
90452   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90453
90454   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90455   if (!arg1) {
90456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90457     return 0;
90458   }
90459   {
90460     try {
90461       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
90462     } catch (std::out_of_range& e) {
90463       {
90464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90465       };
90466     } catch (std::exception& e) {
90467       {
90468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90469       };
90470     } catch (Dali::DaliException e) {
90471       {
90472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90473       };
90474     } catch (...) {
90475       {
90476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90477       };
90478     }
90479   }
90480
90481   jresult = (void *)result;
90482   return jresult;
90483 }
90484
90485
90486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
90487   void * jresult ;
90488   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90489   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
90490   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90491
90492   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90493   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
90494   if (!arg2) {
90495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90496     return 0;
90497   }
90498   {
90499     try {
90500       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
90501     } catch (std::out_of_range& e) {
90502       {
90503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90504       };
90505     } catch (std::exception& e) {
90506       {
90507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90508       };
90509     } catch (Dali::DaliException e) {
90510       {
90511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90512       };
90513     } catch (...) {
90514       {
90515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90516       };
90517     }
90518   }
90519
90520   jresult = (void *)result;
90521   return jresult;
90522 }
90523
90524
90525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
90526   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90527
90528   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90529   {
90530     try {
90531       delete arg1;
90532     } catch (std::out_of_range& e) {
90533       {
90534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90535       };
90536     } catch (std::exception& e) {
90537       {
90538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90539       };
90540     } catch (Dali::DaliException e) {
90541       {
90542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90543       };
90544     } catch (...) {
90545       {
90546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90547       };
90548     }
90549   }
90550
90551 }
90552
90553
90554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
90555   void * jresult ;
90556   Dali::Toolkit::PageFactory *arg1 = 0 ;
90557   Dali::Vector2 *arg2 = 0 ;
90558   Dali::Toolkit::PageTurnPortraitView result;
90559
90560   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90561   if (!arg1) {
90562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90563     return 0;
90564   }
90565   arg2 = (Dali::Vector2 *)jarg2;
90566   if (!arg2) {
90567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90568     return 0;
90569   }
90570   {
90571     try {
90572       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
90573     } catch (std::out_of_range& e) {
90574       {
90575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90576       };
90577     } catch (std::exception& e) {
90578       {
90579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90580       };
90581     } catch (Dali::DaliException e) {
90582       {
90583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90584       };
90585     } catch (...) {
90586       {
90587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90588       };
90589     }
90590   }
90591
90592   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
90593   return jresult;
90594 }
90595
90596
90597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
90598   void * jresult ;
90599   Dali::BaseHandle arg1 ;
90600   Dali::BaseHandle *argp1 ;
90601   Dali::Toolkit::PageTurnPortraitView result;
90602
90603   argp1 = (Dali::BaseHandle *)jarg1;
90604   if (!argp1) {
90605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90606     return 0;
90607   }
90608   arg1 = *argp1;
90609   {
90610     try {
90611       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
90612     } catch (std::out_of_range& e) {
90613       {
90614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90615       };
90616     } catch (std::exception& e) {
90617       {
90618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90619       };
90620     } catch (Dali::DaliException e) {
90621       {
90622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90623       };
90624     } catch (...) {
90625       {
90626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90627       };
90628     }
90629   }
90630
90631   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
90632   return jresult;
90633 }
90634
90635
90636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
90637   int jresult ;
90638   int result;
90639
90640   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
90641   jresult = (int)result;
90642   return jresult;
90643 }
90644
90645
90646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
90647   int jresult ;
90648   int result;
90649
90650   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
90651   jresult = (int)result;
90652   return jresult;
90653 }
90654
90655
90656 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
90657   int jresult ;
90658   int result;
90659
90660   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
90661   jresult = (int)result;
90662   return jresult;
90663 }
90664
90665
90666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
90667   void * jresult ;
90668   Dali::Toolkit::ToggleButton::Property *result = 0 ;
90669
90670   {
90671     try {
90672       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
90673     } catch (std::out_of_range& e) {
90674       {
90675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90676       };
90677     } catch (std::exception& e) {
90678       {
90679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90680       };
90681     } catch (Dali::DaliException e) {
90682       {
90683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90684       };
90685     } catch (...) {
90686       {
90687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90688       };
90689     }
90690   }
90691
90692   jresult = (void *)result;
90693   return jresult;
90694 }
90695
90696
90697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
90698   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
90699
90700   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
90701   {
90702     try {
90703       delete arg1;
90704     } catch (std::out_of_range& e) {
90705       {
90706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90707       };
90708     } catch (std::exception& e) {
90709       {
90710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90711       };
90712     } catch (Dali::DaliException e) {
90713       {
90714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90715       };
90716     } catch (...) {
90717       {
90718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90719       };
90720     }
90721   }
90722
90723 }
90724
90725
90726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
90727   void * jresult ;
90728   Dali::Toolkit::ToggleButton *result = 0 ;
90729
90730   {
90731     try {
90732       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
90733     } catch (std::out_of_range& e) {
90734       {
90735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90736       };
90737     } catch (std::exception& e) {
90738       {
90739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90740       };
90741     } catch (Dali::DaliException e) {
90742       {
90743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90744       };
90745     } catch (...) {
90746       {
90747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90748       };
90749     }
90750   }
90751
90752   jresult = (void *)result;
90753   return jresult;
90754 }
90755
90756
90757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
90758   void * jresult ;
90759   Dali::Toolkit::ToggleButton *arg1 = 0 ;
90760   Dali::Toolkit::ToggleButton *result = 0 ;
90761
90762   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90763   if (!arg1) {
90764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
90765     return 0;
90766   }
90767   {
90768     try {
90769       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
90770     } catch (std::out_of_range& e) {
90771       {
90772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90773       };
90774     } catch (std::exception& e) {
90775       {
90776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90777       };
90778     } catch (Dali::DaliException e) {
90779       {
90780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90781       };
90782     } catch (...) {
90783       {
90784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90785       };
90786     }
90787   }
90788
90789   jresult = (void *)result;
90790   return jresult;
90791 }
90792
90793
90794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
90795   void * jresult ;
90796   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
90797   Dali::Toolkit::ToggleButton *arg2 = 0 ;
90798   Dali::Toolkit::ToggleButton *result = 0 ;
90799
90800   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90801   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
90802   if (!arg2) {
90803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
90804     return 0;
90805   }
90806   {
90807     try {
90808       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
90809     } catch (std::out_of_range& e) {
90810       {
90811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90812       };
90813     } catch (std::exception& e) {
90814       {
90815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90816       };
90817     } catch (Dali::DaliException e) {
90818       {
90819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90820       };
90821     } catch (...) {
90822       {
90823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90824       };
90825     }
90826   }
90827
90828   jresult = (void *)result;
90829   return jresult;
90830 }
90831
90832
90833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
90834   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
90835
90836   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90837   {
90838     try {
90839       delete arg1;
90840     } catch (std::out_of_range& e) {
90841       {
90842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90843       };
90844     } catch (std::exception& e) {
90845       {
90846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90847       };
90848     } catch (Dali::DaliException e) {
90849       {
90850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90851       };
90852     } catch (...) {
90853       {
90854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90855       };
90856     }
90857   }
90858
90859 }
90860
90861
90862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
90863   void * jresult ;
90864   Dali::Toolkit::ToggleButton result;
90865
90866   {
90867     try {
90868       result = Dali::Toolkit::ToggleButton::New();
90869     } catch (std::out_of_range& e) {
90870       {
90871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90872       };
90873     } catch (std::exception& e) {
90874       {
90875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90876       };
90877     } catch (Dali::DaliException e) {
90878       {
90879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90880       };
90881     } catch (...) {
90882       {
90883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90884       };
90885     }
90886   }
90887
90888   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
90889   return jresult;
90890 }
90891
90892
90893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
90894   void * jresult ;
90895   Dali::BaseHandle arg1 ;
90896   Dali::BaseHandle *argp1 ;
90897   Dali::Toolkit::ToggleButton result;
90898
90899   argp1 = (Dali::BaseHandle *)jarg1;
90900   if (!argp1) {
90901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90902     return 0;
90903   }
90904   arg1 = *argp1;
90905   {
90906     try {
90907       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
90908     } catch (std::out_of_range& e) {
90909       {
90910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90911       };
90912     } catch (std::exception& e) {
90913       {
90914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90915       };
90916     } catch (Dali::DaliException e) {
90917       {
90918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90919       };
90920     } catch (...) {
90921       {
90922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90923       };
90924     }
90925   }
90926
90927   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
90928   return jresult;
90929 }
90930
90931
90932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
90933   void * jresult ;
90934   Dali::Toolkit::Visual::Base *result = 0 ;
90935
90936   {
90937     try {
90938       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
90939     } catch (std::out_of_range& e) {
90940       {
90941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90942       };
90943     } catch (std::exception& e) {
90944       {
90945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90946       };
90947     } catch (Dali::DaliException e) {
90948       {
90949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90950       };
90951     } catch (...) {
90952       {
90953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90954       };
90955     }
90956   }
90957
90958   jresult = (void *)result;
90959   return jresult;
90960 }
90961
90962
90963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
90964   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90965
90966   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90967   {
90968     try {
90969       delete arg1;
90970     } catch (std::out_of_range& e) {
90971       {
90972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90973       };
90974     } catch (std::exception& e) {
90975       {
90976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90977       };
90978     } catch (Dali::DaliException e) {
90979       {
90980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90981       };
90982     } catch (...) {
90983       {
90984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90985       };
90986     }
90987   }
90988
90989 }
90990
90991
90992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
90993   void * jresult ;
90994   Dali::Toolkit::Visual::Base *arg1 = 0 ;
90995   Dali::Toolkit::Visual::Base *result = 0 ;
90996
90997   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90998   if (!arg1) {
90999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
91000     return 0;
91001   }
91002   {
91003     try {
91004       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
91005     } catch (std::out_of_range& e) {
91006       {
91007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91008       };
91009     } catch (std::exception& e) {
91010       {
91011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91012       };
91013     } catch (Dali::DaliException e) {
91014       {
91015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91016       };
91017     } catch (...) {
91018       {
91019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91020       };
91021     }
91022   }
91023
91024   jresult = (void *)result;
91025   return jresult;
91026 }
91027
91028
91029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
91030   void * jresult ;
91031   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91032   Dali::Toolkit::Visual::Base *arg2 = 0 ;
91033   Dali::Toolkit::Visual::Base *result = 0 ;
91034
91035   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91036   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
91037   if (!arg2) {
91038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
91039     return 0;
91040   }
91041   {
91042     try {
91043       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
91044     } catch (std::out_of_range& e) {
91045       {
91046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91047       };
91048     } catch (std::exception& e) {
91049       {
91050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91051       };
91052     } catch (Dali::DaliException e) {
91053       {
91054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91055       };
91056     } catch (...) {
91057       {
91058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91059       };
91060     }
91061   }
91062
91063   jresult = (void *)result;
91064   return jresult;
91065 }
91066
91067
91068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
91069   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91070   std::string *arg2 = 0 ;
91071
91072   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91073   if (!jarg2) {
91074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91075     return ;
91076   }
91077   std::string arg2_str(jarg2);
91078   arg2 = &arg2_str;
91079   {
91080     try {
91081       (arg1)->SetName((std::string const &)*arg2);
91082     } catch (std::out_of_range& e) {
91083       {
91084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91085       };
91086     } catch (std::exception& e) {
91087       {
91088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91089       };
91090     } catch (Dali::DaliException e) {
91091       {
91092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91093       };
91094     } catch (...) {
91095       {
91096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91097       };
91098     }
91099   }
91100
91101
91102   //argout typemap for const std::string&
91103
91104 }
91105
91106
91107 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
91108   char * jresult ;
91109   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91110   std::string *result = 0 ;
91111
91112   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91113   {
91114     try {
91115       result = (std::string *) &(arg1)->GetName();
91116     } catch (std::out_of_range& e) {
91117       {
91118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91119       };
91120     } catch (std::exception& e) {
91121       {
91122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91123       };
91124     } catch (Dali::DaliException e) {
91125       {
91126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91127       };
91128     } catch (...) {
91129       {
91130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91131       };
91132     }
91133   }
91134
91135   jresult = SWIG_csharp_string_callback(result->c_str());
91136   return jresult;
91137 }
91138
91139
91140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
91141   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91142   Dali::Property::Map *arg2 = 0 ;
91143   Dali::Size arg3 ;
91144   Dali::Size *argp3 ;
91145
91146   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91147   arg2 = (Dali::Property::Map *)jarg2;
91148   if (!arg2) {
91149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
91150     return ;
91151   }
91152   argp3 = (Dali::Size *)jarg3;
91153   if (!argp3) {
91154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
91155     return ;
91156   }
91157   arg3 = *argp3;
91158   {
91159     try {
91160       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
91161     } catch (std::out_of_range& e) {
91162       {
91163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91164       };
91165     } catch (std::exception& e) {
91166       {
91167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91168       };
91169     } catch (Dali::DaliException e) {
91170       {
91171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91172       };
91173     } catch (...) {
91174       {
91175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91176       };
91177     }
91178   }
91179
91180 }
91181
91182
91183 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
91184   float jresult ;
91185   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91186   float arg2 ;
91187   float result;
91188
91189   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91190   arg2 = (float)jarg2;
91191   {
91192     try {
91193       result = (float)(arg1)->GetHeightForWidth(arg2);
91194     } catch (std::out_of_range& e) {
91195       {
91196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91197       };
91198     } catch (std::exception& e) {
91199       {
91200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91201       };
91202     } catch (Dali::DaliException e) {
91203       {
91204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91205       };
91206     } catch (...) {
91207       {
91208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91209       };
91210     }
91211   }
91212
91213   jresult = result;
91214   return jresult;
91215 }
91216
91217
91218 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
91219   float jresult ;
91220   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91221   float arg2 ;
91222   float result;
91223
91224   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91225   arg2 = (float)jarg2;
91226   {
91227     try {
91228       result = (float)(arg1)->GetWidthForHeight(arg2);
91229     } catch (std::out_of_range& e) {
91230       {
91231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91232       };
91233     } catch (std::exception& e) {
91234       {
91235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91236       };
91237     } catch (Dali::DaliException e) {
91238       {
91239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91240       };
91241     } catch (...) {
91242       {
91243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91244       };
91245     }
91246   }
91247
91248   jresult = result;
91249   return jresult;
91250 }
91251
91252
91253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
91254   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91255   Dali::Vector2 *arg2 = 0 ;
91256
91257   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91258   arg2 = (Dali::Vector2 *)jarg2;
91259   if (!arg2) {
91260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
91261     return ;
91262   }
91263   {
91264     try {
91265       (arg1)->GetNaturalSize(*arg2);
91266     } catch (std::out_of_range& e) {
91267       {
91268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91269       };
91270     } catch (std::exception& e) {
91271       {
91272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91273       };
91274     } catch (Dali::DaliException e) {
91275       {
91276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91277       };
91278     } catch (...) {
91279       {
91280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91281       };
91282     }
91283   }
91284
91285 }
91286
91287
91288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
91289   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91290   float arg2 ;
91291
91292   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91293   arg2 = (int)jarg2;
91294   {
91295     try {
91296       (arg1)->SetDepthIndex(arg2);
91297     } catch (std::out_of_range& e) {
91298       {
91299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91300       };
91301     } catch (std::exception& e) {
91302       {
91303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91304       };
91305     } catch (Dali::DaliException e) {
91306       {
91307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91308       };
91309     } catch (...) {
91310       {
91311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91312       };
91313     }
91314   }
91315
91316 }
91317
91318
91319 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
91320   int jresult ;
91321   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91322   int result;
91323
91324   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91325   {
91326     try {
91327       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
91328     } catch (std::out_of_range& e) {
91329       {
91330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91331       };
91332     } catch (std::exception& e) {
91333       {
91334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91335       };
91336     } catch (Dali::DaliException e) {
91337       {
91338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91339       };
91340     } catch (...) {
91341       {
91342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91343       };
91344     }
91345   }
91346
91347   jresult = result;
91348   return jresult;
91349 }
91350
91351
91352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
91353   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91354   Dali::Property::Map *arg2 = 0 ;
91355
91356   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91357   arg2 = (Dali::Property::Map *)jarg2;
91358   if (!arg2) {
91359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
91360     return ;
91361   }
91362   {
91363     try {
91364       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
91365     } catch (std::out_of_range& e) {
91366       {
91367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91368       };
91369     } catch (std::exception& e) {
91370       {
91371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91372       };
91373     } catch (Dali::DaliException e) {
91374       {
91375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91376       };
91377     } catch (...) {
91378       {
91379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91380       };
91381     }
91382   }
91383
91384 }
91385
91386
91387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_2(void * jarg1) {
91388   void * jresult ;
91389   Dali::Toolkit::Internal::Visual::Base *arg1 = (Dali::Toolkit::Internal::Visual::Base *) 0 ;
91390   Dali::Toolkit::Visual::Base *result = 0 ;
91391
91392   arg1 = (Dali::Toolkit::Internal::Visual::Base *)jarg1;
91393   {
91394     try {
91395       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base(arg1);
91396     } catch (std::out_of_range& e) {
91397       {
91398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91399       };
91400     } catch (std::exception& e) {
91401       {
91402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91403       };
91404     } catch (Dali::DaliException e) {
91405       {
91406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91407       };
91408     } catch (...) {
91409       {
91410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91411       };
91412     }
91413   }
91414
91415   jresult = (void *)result;
91416   return jresult;
91417 }
91418
91419
91420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
91421   void * jresult ;
91422   Dali::Toolkit::VisualFactory result;
91423
91424   {
91425     try {
91426       result = Dali::Toolkit::VisualFactory::Get();
91427     } catch (std::out_of_range& e) {
91428       {
91429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91430       };
91431     } catch (std::exception& e) {
91432       {
91433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91434       };
91435     } catch (Dali::DaliException e) {
91436       {
91437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91438       };
91439     } catch (...) {
91440       {
91441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91442       };
91443     }
91444   }
91445
91446   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
91447   return jresult;
91448 }
91449
91450
91451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
91452   void * jresult ;
91453   Dali::Toolkit::VisualFactory *result = 0 ;
91454
91455   {
91456     try {
91457       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
91458     } catch (std::out_of_range& e) {
91459       {
91460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91461       };
91462     } catch (std::exception& e) {
91463       {
91464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91465       };
91466     } catch (Dali::DaliException e) {
91467       {
91468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91469       };
91470     } catch (...) {
91471       {
91472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91473       };
91474     }
91475   }
91476
91477   jresult = (void *)result;
91478   return jresult;
91479 }
91480
91481
91482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
91483   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91484
91485   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91486   {
91487     try {
91488       delete arg1;
91489     } catch (std::out_of_range& e) {
91490       {
91491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91492       };
91493     } catch (std::exception& e) {
91494       {
91495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91496       };
91497     } catch (Dali::DaliException e) {
91498       {
91499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91500       };
91501     } catch (...) {
91502       {
91503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91504       };
91505     }
91506   }
91507
91508 }
91509
91510
91511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
91512   void * jresult ;
91513   Dali::Toolkit::VisualFactory *arg1 = 0 ;
91514   Dali::Toolkit::VisualFactory *result = 0 ;
91515
91516   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91517   if (!arg1) {
91518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91519     return 0;
91520   }
91521   {
91522     try {
91523       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
91524     } catch (std::out_of_range& e) {
91525       {
91526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91527       };
91528     } catch (std::exception& e) {
91529       {
91530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91531       };
91532     } catch (Dali::DaliException e) {
91533       {
91534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91535       };
91536     } catch (...) {
91537       {
91538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91539       };
91540     }
91541   }
91542
91543   jresult = (void *)result;
91544   return jresult;
91545 }
91546
91547
91548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
91549   void * jresult ;
91550   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91551   Dali::Toolkit::VisualFactory *arg2 = 0 ;
91552   Dali::Toolkit::VisualFactory *result = 0 ;
91553
91554   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91555   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
91556   if (!arg2) {
91557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91558     return 0;
91559   }
91560   {
91561     try {
91562       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
91563     } catch (std::out_of_range& e) {
91564       {
91565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91566       };
91567     } catch (std::exception& e) {
91568       {
91569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91570       };
91571     } catch (Dali::DaliException e) {
91572       {
91573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91574       };
91575     } catch (...) {
91576       {
91577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91578       };
91579     }
91580   }
91581
91582   jresult = (void *)result;
91583   return jresult;
91584 }
91585
91586
91587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
91588   void * jresult ;
91589   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91590   Dali::Property::Map *arg2 = 0 ;
91591   Dali::Toolkit::Visual::Base result;
91592
91593   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91594   arg2 = (Dali::Property::Map *)jarg2;
91595   if (!arg2) {
91596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
91597     return 0;
91598   }
91599   {
91600     try {
91601       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
91602     } catch (std::out_of_range& e) {
91603       {
91604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91605       };
91606     } catch (std::exception& e) {
91607       {
91608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91609       };
91610     } catch (Dali::DaliException e) {
91611       {
91612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91613       };
91614     } catch (...) {
91615       {
91616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91617       };
91618     }
91619   }
91620
91621   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91622   return jresult;
91623 }
91624
91625
91626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
91627   void * jresult ;
91628   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91629   Dali::Image *arg2 = 0 ;
91630   Dali::Toolkit::Visual::Base result;
91631
91632   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91633   arg2 = (Dali::Image *)jarg2;
91634   if (!arg2) {
91635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
91636     return 0;
91637   }
91638   {
91639     try {
91640       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
91641     } catch (std::out_of_range& e) {
91642       {
91643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91644       };
91645     } catch (std::exception& e) {
91646       {
91647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91648       };
91649     } catch (Dali::DaliException e) {
91650       {
91651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91652       };
91653     } catch (...) {
91654       {
91655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91656       };
91657     }
91658   }
91659
91660   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91661   return jresult;
91662 }
91663
91664
91665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
91666   void * jresult ;
91667   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91668   std::string *arg2 = 0 ;
91669   Dali::ImageDimensions arg3 ;
91670   Dali::ImageDimensions *argp3 ;
91671   Dali::Toolkit::Visual::Base result;
91672
91673   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91674   if (!jarg2) {
91675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91676     return 0;
91677   }
91678   std::string arg2_str(jarg2);
91679   arg2 = &arg2_str;
91680   argp3 = (Dali::ImageDimensions *)jarg3;
91681   if (!argp3) {
91682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91683     return 0;
91684   }
91685   arg3 = *argp3;
91686   {
91687     try {
91688       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
91689     } catch (std::out_of_range& e) {
91690       {
91691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91692       };
91693     } catch (std::exception& e) {
91694       {
91695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91696       };
91697     } catch (Dali::DaliException e) {
91698       {
91699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91700       };
91701     } catch (...) {
91702       {
91703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91704       };
91705     }
91706   }
91707
91708   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91709
91710   //argout typemap for const std::string&
91711
91712   return jresult;
91713 }
91714
91715
91716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
91717   void * jresult ;
91718   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91719
91720   {
91721     try {
91722       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
91723     } catch (std::out_of_range& e) {
91724       {
91725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91726       };
91727     } catch (std::exception& e) {
91728       {
91729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91730       };
91731     } catch (Dali::DaliException e) {
91732       {
91733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91734       };
91735     } catch (...) {
91736       {
91737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91738       };
91739     }
91740   }
91741
91742   jresult = (void *)result;
91743   return jresult;
91744 }
91745
91746
91747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
91748   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91749
91750   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91751   {
91752     try {
91753       delete arg1;
91754     } catch (std::out_of_range& e) {
91755       {
91756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91757       };
91758     } catch (std::exception& e) {
91759       {
91760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91761       };
91762     } catch (Dali::DaliException e) {
91763       {
91764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91765       };
91766     } catch (...) {
91767       {
91768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91769       };
91770     }
91771   }
91772
91773 }
91774
91775
91776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
91777   void * jresult ;
91778   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
91779   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91780
91781   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91782   if (!arg1) {
91783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
91784     return 0;
91785   }
91786   {
91787     try {
91788       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
91789     } catch (std::out_of_range& e) {
91790       {
91791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91792       };
91793     } catch (std::exception& e) {
91794       {
91795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91796       };
91797     } catch (Dali::DaliException e) {
91798       {
91799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91800       };
91801     } catch (...) {
91802       {
91803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91804       };
91805     }
91806   }
91807
91808   jresult = (void *)result;
91809   return jresult;
91810 }
91811
91812
91813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
91814   void * jresult ;
91815   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91816   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
91817   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91818
91819   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91820   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
91821   if (!arg2) {
91822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
91823     return 0;
91824   }
91825   {
91826     try {
91827       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
91828     } catch (std::out_of_range& e) {
91829       {
91830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91831       };
91832     } catch (std::exception& e) {
91833       {
91834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91835       };
91836     } catch (Dali::DaliException e) {
91837       {
91838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91839       };
91840     } catch (...) {
91841       {
91842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91843       };
91844     }
91845   }
91846
91847   jresult = (void *)result;
91848   return jresult;
91849 }
91850
91851
91852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
91853   void * jresult ;
91854   Dali::Toolkit::AsyncImageLoader result;
91855
91856   {
91857     try {
91858       result = Dali::Toolkit::AsyncImageLoader::New();
91859     } catch (std::out_of_range& e) {
91860       {
91861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91862       };
91863     } catch (std::exception& e) {
91864       {
91865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91866       };
91867     } catch (Dali::DaliException e) {
91868       {
91869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91870       };
91871     } catch (...) {
91872       {
91873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91874       };
91875     }
91876   }
91877
91878   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
91879   return jresult;
91880 }
91881
91882
91883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
91884   void * jresult ;
91885   Dali::BaseHandle arg1 ;
91886   Dali::BaseHandle *argp1 ;
91887   Dali::Toolkit::AsyncImageLoader result;
91888
91889   argp1 = (Dali::BaseHandle *)jarg1;
91890   if (!argp1) {
91891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
91892     return 0;
91893   }
91894   arg1 = *argp1;
91895   {
91896     try {
91897       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
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 = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
91918   return jresult;
91919 }
91920
91921
91922 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
91923   unsigned int jresult ;
91924   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91925   std::string *arg2 = 0 ;
91926   uint32_t result;
91927
91928   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91929   if (!jarg2) {
91930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91931     return 0;
91932   }
91933   std::string arg2_str(jarg2);
91934   arg2 = &arg2_str;
91935   {
91936     try {
91937       result = (arg1)->Load((std::string const &)*arg2);
91938     } catch (std::out_of_range& e) {
91939       {
91940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91941       };
91942     } catch (std::exception& e) {
91943       {
91944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91945       };
91946     } catch (Dali::DaliException e) {
91947       {
91948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91949       };
91950     } catch (...) {
91951       {
91952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91953       };
91954     }
91955   }
91956
91957   jresult = result;
91958
91959   //argout typemap for const std::string&
91960
91961   return jresult;
91962 }
91963
91964
91965 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
91966   unsigned int jresult ;
91967   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91968   std::string *arg2 = 0 ;
91969   Dali::ImageDimensions arg3 ;
91970   Dali::ImageDimensions *argp3 ;
91971   uint32_t result;
91972
91973   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91974   if (!jarg2) {
91975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91976     return 0;
91977   }
91978   std::string arg2_str(jarg2);
91979   arg2 = &arg2_str;
91980   argp3 = (Dali::ImageDimensions *)jarg3;
91981   if (!argp3) {
91982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91983     return 0;
91984   }
91985   arg3 = *argp3;
91986   {
91987     try {
91988       result = (arg1)->Load((std::string const &)*arg2,arg3);
91989     } catch (std::out_of_range& e) {
91990       {
91991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91992       };
91993     } catch (std::exception& e) {
91994       {
91995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91996       };
91997     } catch (Dali::DaliException e) {
91998       {
91999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92000       };
92001     } catch (...) {
92002       {
92003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92004       };
92005     }
92006   }
92007
92008   jresult = result;
92009
92010   //argout typemap for const std::string&
92011
92012   return jresult;
92013 }
92014
92015
92016 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
92017   unsigned int jresult ;
92018   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92019   std::string *arg2 = 0 ;
92020   Dali::ImageDimensions arg3 ;
92021   Dali::FittingMode::Type arg4 ;
92022   Dali::SamplingMode::Type arg5 ;
92023   bool arg6 ;
92024   Dali::ImageDimensions *argp3 ;
92025   uint32_t result;
92026
92027   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92028   if (!jarg2) {
92029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92030     return 0;
92031   }
92032   std::string arg2_str(jarg2);
92033   arg2 = &arg2_str;
92034   argp3 = (Dali::ImageDimensions *)jarg3;
92035   if (!argp3) {
92036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92037     return 0;
92038   }
92039   arg3 = *argp3;
92040   arg4 = (Dali::FittingMode::Type)jarg4;
92041   arg5 = (Dali::SamplingMode::Type)jarg5;
92042   arg6 = jarg6 ? true : false;
92043   {
92044     try {
92045       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
92046     } catch (std::out_of_range& e) {
92047       {
92048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92049       };
92050     } catch (std::exception& e) {
92051       {
92052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92053       };
92054     } catch (Dali::DaliException e) {
92055       {
92056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92057       };
92058     } catch (...) {
92059       {
92060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92061       };
92062     }
92063   }
92064
92065   jresult = result;
92066
92067   //argout typemap for const std::string&
92068
92069   return jresult;
92070 }
92071
92072
92073 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
92074   unsigned int jresult ;
92075   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92076   uint32_t arg2 ;
92077   bool result;
92078
92079   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92080   arg2 = (uint32_t)jarg2;
92081   {
92082     try {
92083       result = (bool)(arg1)->Cancel(arg2);
92084     } catch (std::out_of_range& e) {
92085       {
92086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92087       };
92088     } catch (std::exception& e) {
92089       {
92090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92091       };
92092     } catch (Dali::DaliException e) {
92093       {
92094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92095       };
92096     } catch (...) {
92097       {
92098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92099       };
92100     }
92101   }
92102
92103   jresult = result;
92104   return jresult;
92105 }
92106
92107
92108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
92109   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92110
92111   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92112   {
92113     try {
92114       (arg1)->CancelAll();
92115     } catch (std::out_of_range& e) {
92116       {
92117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92118       };
92119     } catch (std::exception& e) {
92120       {
92121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92122       };
92123     } catch (Dali::DaliException e) {
92124       {
92125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92126       };
92127     } catch (...) {
92128       {
92129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92130       };
92131     }
92132   }
92133
92134 }
92135
92136
92137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
92138   void * jresult ;
92139   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92140   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
92141
92142   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92143   {
92144     try {
92145       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
92146     } catch (std::out_of_range& e) {
92147       {
92148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92149       };
92150     } catch (std::exception& e) {
92151       {
92152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92153       };
92154     } catch (Dali::DaliException e) {
92155       {
92156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92157       };
92158     } catch (...) {
92159       {
92160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92161       };
92162     }
92163   }
92164
92165   jresult = (void *)result;
92166   return jresult;
92167 }
92168
92169
92170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_2(void * jarg1) {
92171   void * jresult ;
92172   Dali::Toolkit::Internal::AsyncImageLoader *arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *) 0 ;
92173   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92174
92175   arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *)jarg1;
92176   {
92177     try {
92178       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader(arg1);
92179     } catch (std::out_of_range& e) {
92180       {
92181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92182       };
92183     } catch (std::exception& e) {
92184       {
92185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92186       };
92187     } catch (Dali::DaliException e) {
92188       {
92189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92190       };
92191     } catch (...) {
92192       {
92193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92194       };
92195     }
92196   }
92197
92198   jresult = (void *)result;
92199   return jresult;
92200 }
92201
92202
92203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
92204   void * jresult ;
92205   std::string *arg1 = 0 ;
92206   Dali::PixelData result;
92207
92208   if (!jarg1) {
92209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92210     return 0;
92211   }
92212   std::string arg1_str(jarg1);
92213   arg1 = &arg1_str;
92214   {
92215     try {
92216       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
92217     } catch (std::out_of_range& e) {
92218       {
92219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92220       };
92221     } catch (std::exception& e) {
92222       {
92223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92224       };
92225     } catch (Dali::DaliException e) {
92226       {
92227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92228       };
92229     } catch (...) {
92230       {
92231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92232       };
92233     }
92234   }
92235
92236   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92237
92238   //argout typemap for const std::string&
92239
92240   return jresult;
92241 }
92242
92243
92244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
92245   void * jresult ;
92246   std::string *arg1 = 0 ;
92247   Dali::ImageDimensions arg2 ;
92248   Dali::ImageDimensions *argp2 ;
92249   Dali::PixelData result;
92250
92251   if (!jarg1) {
92252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92253     return 0;
92254   }
92255   std::string arg1_str(jarg1);
92256   arg1 = &arg1_str;
92257   argp2 = (Dali::ImageDimensions *)jarg2;
92258   if (!argp2) {
92259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92260     return 0;
92261   }
92262   arg2 = *argp2;
92263   {
92264     try {
92265       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
92266     } catch (std::out_of_range& e) {
92267       {
92268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92269       };
92270     } catch (std::exception& e) {
92271       {
92272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92273       };
92274     } catch (Dali::DaliException e) {
92275       {
92276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92277       };
92278     } catch (...) {
92279       {
92280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92281       };
92282     }
92283   }
92284
92285   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92286
92287   //argout typemap for const std::string&
92288
92289   return jresult;
92290 }
92291
92292
92293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
92294   void * jresult ;
92295   std::string *arg1 = 0 ;
92296   Dali::ImageDimensions arg2 ;
92297   Dali::FittingMode::Type arg3 ;
92298   Dali::SamplingMode::Type arg4 ;
92299   bool arg5 ;
92300   Dali::ImageDimensions *argp2 ;
92301   Dali::PixelData result;
92302
92303   if (!jarg1) {
92304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92305     return 0;
92306   }
92307   std::string arg1_str(jarg1);
92308   arg1 = &arg1_str;
92309   argp2 = (Dali::ImageDimensions *)jarg2;
92310   if (!argp2) {
92311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92312     return 0;
92313   }
92314   arg2 = *argp2;
92315   arg3 = (Dali::FittingMode::Type)jarg3;
92316   arg4 = (Dali::SamplingMode::Type)jarg4;
92317   arg5 = jarg5 ? true : false;
92318   {
92319     try {
92320       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
92321     } catch (std::out_of_range& e) {
92322       {
92323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92324       };
92325     } catch (std::exception& e) {
92326       {
92327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92328       };
92329     } catch (Dali::DaliException e) {
92330       {
92331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92332       };
92333     } catch (...) {
92334       {
92335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92336       };
92337     }
92338   }
92339
92340   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92341
92342   //argout typemap for const std::string&
92343
92344   return jresult;
92345 }
92346
92347
92348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
92349   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92350
92351   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92352   {
92353     try {
92354       delete arg1;
92355     } catch (std::out_of_range& e) {
92356       {
92357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92358       };
92359     } catch (std::exception& e) {
92360       {
92361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92362       };
92363     } catch (Dali::DaliException e) {
92364       {
92365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92366       };
92367     } catch (...) {
92368       {
92369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92370       };
92371     }
92372   }
92373
92374 }
92375
92376
92377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
92378   void * jresult ;
92379   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92380   Dali::Actor arg2 ;
92381   Dali::Actor arg3 ;
92382   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
92383   Dali::Actor *argp2 ;
92384   Dali::Actor *argp3 ;
92385   Dali::Actor result;
92386
92387   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92388   argp2 = (Dali::Actor *)jarg2;
92389   if (!argp2) {
92390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92391     return 0;
92392   }
92393   arg2 = *argp2;
92394   argp3 = (Dali::Actor *)jarg3;
92395   if (!argp3) {
92396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92397     return 0;
92398   }
92399   arg3 = *argp3;
92400   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
92401   {
92402     try {
92403       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
92404     } catch (std::out_of_range& e) {
92405       {
92406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92407       };
92408     } catch (std::exception& e) {
92409       {
92410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92411       };
92412     } catch (Dali::DaliException e) {
92413       {
92414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92415       };
92416     } catch (...) {
92417       {
92418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92419       };
92420     }
92421   }
92422
92423   jresult = new Dali::Actor((const Dali::Actor &)result);
92424   return jresult;
92425 }
92426
92427
92428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
92429   void * jresult ;
92430   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
92431
92432   {
92433     try {
92434       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
92435     } catch (std::out_of_range& e) {
92436       {
92437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92438       };
92439     } catch (std::exception& e) {
92440       {
92441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92442       };
92443     } catch (Dali::DaliException e) {
92444       {
92445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92446       };
92447     } catch (...) {
92448       {
92449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92450       };
92451     }
92452   }
92453
92454   jresult = (void *)result;
92455   return jresult;
92456 }
92457
92458
92459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
92460   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
92461   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
92462   if (director) {
92463     director->swig_connect_director(callback0);
92464   }
92465 }
92466
92467
92468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
92469   KeyboardFocusManager arg1 ;
92470   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
92471   KeyboardFocusManager *argp1 ;
92472
92473   argp1 = (KeyboardFocusManager *)jarg1;
92474   if (!argp1) {
92475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
92476     return ;
92477   }
92478   arg1 = *argp1;
92479   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
92480   if (!arg2) {
92481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
92482     return ;
92483   }
92484   {
92485     try {
92486       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
92487     } catch (std::out_of_range& e) {
92488       {
92489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92490       };
92491     } catch (std::exception& e) {
92492       {
92493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92494       };
92495     } catch (Dali::DaliException e) {
92496       {
92497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92498       };
92499     } catch (...) {
92500       {
92501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92502       };
92503     }
92504   }
92505
92506 }
92507
92508
92509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
92510   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92511
92512   arg1 = (std::vector< unsigned int > *)jarg1;
92513   {
92514     try {
92515       (arg1)->clear();
92516     } catch (std::out_of_range& e) {
92517       {
92518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92519       };
92520     } catch (std::exception& e) {
92521       {
92522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92523       };
92524     } catch (Dali::DaliException e) {
92525       {
92526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92527       };
92528     } catch (...) {
92529       {
92530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92531       };
92532     }
92533   }
92534
92535 }
92536
92537
92538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
92539   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92540   unsigned int *arg2 = 0 ;
92541   unsigned int temp2 ;
92542
92543   arg1 = (std::vector< unsigned int > *)jarg1;
92544   temp2 = (unsigned int)jarg2;
92545   arg2 = &temp2;
92546   {
92547     try {
92548       (arg1)->push_back((unsigned int const &)*arg2);
92549     } catch (std::out_of_range& e) {
92550       {
92551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92552       };
92553     } catch (std::exception& e) {
92554       {
92555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92556       };
92557     } catch (Dali::DaliException e) {
92558       {
92559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92560       };
92561     } catch (...) {
92562       {
92563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92564       };
92565     }
92566   }
92567
92568 }
92569
92570
92571 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
92572   unsigned long jresult ;
92573   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92574   std::vector< unsigned int >::size_type result;
92575
92576   arg1 = (std::vector< unsigned int > *)jarg1;
92577   {
92578     try {
92579       result = ((std::vector< unsigned int > const *)arg1)->size();
92580     } catch (std::out_of_range& e) {
92581       {
92582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92583       };
92584     } catch (std::exception& e) {
92585       {
92586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92587       };
92588     } catch (Dali::DaliException e) {
92589       {
92590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92591       };
92592     } catch (...) {
92593       {
92594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92595       };
92596     }
92597   }
92598
92599   jresult = (unsigned long)result;
92600   return jresult;
92601 }
92602
92603
92604 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
92605   unsigned long jresult ;
92606   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92607   std::vector< unsigned int >::size_type result;
92608
92609   arg1 = (std::vector< unsigned int > *)jarg1;
92610   {
92611     try {
92612       result = ((std::vector< unsigned int > const *)arg1)->capacity();
92613     } catch (std::out_of_range& e) {
92614       {
92615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92616       };
92617     } catch (std::exception& e) {
92618       {
92619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92620       };
92621     } catch (Dali::DaliException e) {
92622       {
92623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92624       };
92625     } catch (...) {
92626       {
92627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92628       };
92629     }
92630   }
92631
92632   jresult = (unsigned long)result;
92633   return jresult;
92634 }
92635
92636
92637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
92638   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92639   std::vector< unsigned int >::size_type arg2 ;
92640
92641   arg1 = (std::vector< unsigned int > *)jarg1;
92642   arg2 = (std::vector< unsigned int >::size_type)jarg2;
92643   {
92644     try {
92645       (arg1)->reserve(arg2);
92646     } catch (std::out_of_range& e) {
92647       {
92648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92649       };
92650     } catch (std::exception& e) {
92651       {
92652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92653       };
92654     } catch (Dali::DaliException e) {
92655       {
92656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92657       };
92658     } catch (...) {
92659       {
92660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92661       };
92662     }
92663   }
92664
92665 }
92666
92667
92668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
92669   void * jresult ;
92670   std::vector< unsigned int > *result = 0 ;
92671
92672   {
92673     try {
92674       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
92675     } catch (std::out_of_range& e) {
92676       {
92677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92678       };
92679     } catch (std::exception& e) {
92680       {
92681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92682       };
92683     } catch (Dali::DaliException e) {
92684       {
92685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92686       };
92687     } catch (...) {
92688       {
92689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92690       };
92691     }
92692   }
92693
92694   jresult = (void *)result;
92695   return jresult;
92696 }
92697
92698
92699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
92700   void * jresult ;
92701   std::vector< unsigned int > *arg1 = 0 ;
92702   std::vector< unsigned int > *result = 0 ;
92703
92704   arg1 = (std::vector< unsigned int > *)jarg1;
92705   if (!arg1) {
92706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92707     return 0;
92708   }
92709   {
92710     try {
92711       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
92712     } catch (std::out_of_range& e) {
92713       {
92714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92715       };
92716     } catch (std::exception& e) {
92717       {
92718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92719       };
92720     } catch (Dali::DaliException e) {
92721       {
92722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92723       };
92724     } catch (...) {
92725       {
92726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92727       };
92728     }
92729   }
92730
92731   jresult = (void *)result;
92732   return jresult;
92733 }
92734
92735
92736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
92737   void * jresult ;
92738   int arg1 ;
92739   std::vector< unsigned int > *result = 0 ;
92740
92741   arg1 = (int)jarg1;
92742   {
92743     try {
92744       try {
92745         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
92746       }
92747       catch(std::out_of_range &_e) {
92748         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92749         return 0;
92750       }
92751
92752     } catch (std::out_of_range& e) {
92753       {
92754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92755       };
92756     } catch (std::exception& e) {
92757       {
92758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92759       };
92760     } catch (Dali::DaliException e) {
92761       {
92762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92763       };
92764     } catch (...) {
92765       {
92766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92767       };
92768     }
92769   }
92770
92771   jresult = (void *)result;
92772   return jresult;
92773 }
92774
92775
92776 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
92777   unsigned int jresult ;
92778   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92779   int arg2 ;
92780   unsigned int result;
92781
92782   arg1 = (std::vector< unsigned int > *)jarg1;
92783   arg2 = (int)jarg2;
92784   {
92785     try {
92786       try {
92787         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
92788       }
92789       catch(std::out_of_range &_e) {
92790         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92791         return 0;
92792       }
92793
92794     } catch (std::out_of_range& e) {
92795       {
92796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92797       };
92798     } catch (std::exception& e) {
92799       {
92800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92801       };
92802     } catch (Dali::DaliException e) {
92803       {
92804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92805       };
92806     } catch (...) {
92807       {
92808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92809       };
92810     }
92811   }
92812
92813   jresult = result;
92814   return jresult;
92815 }
92816
92817
92818 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
92819   unsigned int jresult ;
92820   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92821   int arg2 ;
92822   unsigned int *result = 0 ;
92823
92824   arg1 = (std::vector< unsigned int > *)jarg1;
92825   arg2 = (int)jarg2;
92826   {
92827     try {
92828       try {
92829         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
92830       }
92831       catch(std::out_of_range &_e) {
92832         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92833         return 0;
92834       }
92835
92836     } catch (std::out_of_range& e) {
92837       {
92838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92839       };
92840     } catch (std::exception& e) {
92841       {
92842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92843       };
92844     } catch (Dali::DaliException e) {
92845       {
92846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92847       };
92848     } catch (...) {
92849       {
92850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92851       };
92852     }
92853   }
92854
92855   jresult = *result;
92856   return jresult;
92857 }
92858
92859
92860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
92861   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92862   int arg2 ;
92863   unsigned int *arg3 = 0 ;
92864   unsigned int temp3 ;
92865
92866   arg1 = (std::vector< unsigned int > *)jarg1;
92867   arg2 = (int)jarg2;
92868   temp3 = (unsigned int)jarg3;
92869   arg3 = &temp3;
92870   {
92871     try {
92872       try {
92873         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
92874       }
92875       catch(std::out_of_range &_e) {
92876         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92877         return ;
92878       }
92879
92880     } catch (std::out_of_range& e) {
92881       {
92882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92883       };
92884     } catch (std::exception& e) {
92885       {
92886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92887       };
92888     } catch (Dali::DaliException e) {
92889       {
92890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92891       };
92892     } catch (...) {
92893       {
92894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92895       };
92896     }
92897   }
92898
92899 }
92900
92901
92902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
92903   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92904   std::vector< unsigned int > *arg2 = 0 ;
92905
92906   arg1 = (std::vector< unsigned int > *)jarg1;
92907   arg2 = (std::vector< unsigned int > *)jarg2;
92908   if (!arg2) {
92909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92910     return ;
92911   }
92912   {
92913     try {
92914       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
92915     } catch (std::out_of_range& e) {
92916       {
92917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92918       };
92919     } catch (std::exception& e) {
92920       {
92921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92922       };
92923     } catch (Dali::DaliException e) {
92924       {
92925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92926       };
92927     } catch (...) {
92928       {
92929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92930       };
92931     }
92932   }
92933
92934 }
92935
92936
92937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
92938   void * jresult ;
92939   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92940   int arg2 ;
92941   int arg3 ;
92942   std::vector< unsigned int > *result = 0 ;
92943
92944   arg1 = (std::vector< unsigned int > *)jarg1;
92945   arg2 = (int)jarg2;
92946   arg3 = (int)jarg3;
92947   {
92948     try {
92949       try {
92950         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
92951       }
92952       catch(std::out_of_range &_e) {
92953         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92954         return 0;
92955       }
92956       catch(std::invalid_argument &_e) {
92957         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92958         return 0;
92959       }
92960
92961     } catch (std::out_of_range& e) {
92962       {
92963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92964       };
92965     } catch (std::exception& e) {
92966       {
92967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92968       };
92969     } catch (Dali::DaliException e) {
92970       {
92971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92972       };
92973     } catch (...) {
92974       {
92975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92976       };
92977     }
92978   }
92979
92980   jresult = (void *)result;
92981   return jresult;
92982 }
92983
92984
92985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
92986   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92987   int arg2 ;
92988   unsigned int *arg3 = 0 ;
92989   unsigned int temp3 ;
92990
92991   arg1 = (std::vector< unsigned int > *)jarg1;
92992   arg2 = (int)jarg2;
92993   temp3 = (unsigned int)jarg3;
92994   arg3 = &temp3;
92995   {
92996     try {
92997       try {
92998         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
92999       }
93000       catch(std::out_of_range &_e) {
93001         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93002         return ;
93003       }
93004
93005     } catch (std::out_of_range& e) {
93006       {
93007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93008       };
93009     } catch (std::exception& e) {
93010       {
93011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93012       };
93013     } catch (Dali::DaliException e) {
93014       {
93015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93016       };
93017     } catch (...) {
93018       {
93019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93020       };
93021     }
93022   }
93023
93024 }
93025
93026
93027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
93028   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93029   int arg2 ;
93030   std::vector< unsigned int > *arg3 = 0 ;
93031
93032   arg1 = (std::vector< unsigned int > *)jarg1;
93033   arg2 = (int)jarg2;
93034   arg3 = (std::vector< unsigned int > *)jarg3;
93035   if (!arg3) {
93036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93037     return ;
93038   }
93039   {
93040     try {
93041       try {
93042         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
93043       }
93044       catch(std::out_of_range &_e) {
93045         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93046         return ;
93047       }
93048
93049     } catch (std::out_of_range& e) {
93050       {
93051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93052       };
93053     } catch (std::exception& e) {
93054       {
93055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93056       };
93057     } catch (Dali::DaliException e) {
93058       {
93059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93060       };
93061     } catch (...) {
93062       {
93063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93064       };
93065     }
93066   }
93067
93068 }
93069
93070
93071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
93072   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93073   int arg2 ;
93074
93075   arg1 = (std::vector< unsigned int > *)jarg1;
93076   arg2 = (int)jarg2;
93077   {
93078     try {
93079       try {
93080         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
93081       }
93082       catch(std::out_of_range &_e) {
93083         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93084         return ;
93085       }
93086
93087     } catch (std::out_of_range& e) {
93088       {
93089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93090       };
93091     } catch (std::exception& e) {
93092       {
93093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93094       };
93095     } catch (Dali::DaliException e) {
93096       {
93097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93098       };
93099     } catch (...) {
93100       {
93101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93102       };
93103     }
93104   }
93105
93106 }
93107
93108
93109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
93110   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93111   int arg2 ;
93112   int arg3 ;
93113
93114   arg1 = (std::vector< unsigned int > *)jarg1;
93115   arg2 = (int)jarg2;
93116   arg3 = (int)jarg3;
93117   {
93118     try {
93119       try {
93120         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
93121       }
93122       catch(std::out_of_range &_e) {
93123         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93124         return ;
93125       }
93126       catch(std::invalid_argument &_e) {
93127         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93128         return ;
93129       }
93130
93131     } catch (std::out_of_range& e) {
93132       {
93133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93134       };
93135     } catch (std::exception& e) {
93136       {
93137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93138       };
93139     } catch (Dali::DaliException e) {
93140       {
93141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93142       };
93143     } catch (...) {
93144       {
93145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93146       };
93147     }
93148   }
93149
93150 }
93151
93152
93153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
93154   void * jresult ;
93155   unsigned int *arg1 = 0 ;
93156   int arg2 ;
93157   unsigned int temp1 ;
93158   std::vector< unsigned int > *result = 0 ;
93159
93160   temp1 = (unsigned int)jarg1;
93161   arg1 = &temp1;
93162   arg2 = (int)jarg2;
93163   {
93164     try {
93165       try {
93166         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
93167       }
93168       catch(std::out_of_range &_e) {
93169         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93170         return 0;
93171       }
93172
93173     } catch (std::out_of_range& e) {
93174       {
93175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93176       };
93177     } catch (std::exception& e) {
93178       {
93179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93180       };
93181     } catch (Dali::DaliException e) {
93182       {
93183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93184       };
93185     } catch (...) {
93186       {
93187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93188       };
93189     }
93190   }
93191
93192   jresult = (void *)result;
93193   return jresult;
93194 }
93195
93196
93197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
93198   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93199
93200   arg1 = (std::vector< unsigned int > *)jarg1;
93201   {
93202     try {
93203       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
93204     } catch (std::out_of_range& e) {
93205       {
93206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93207       };
93208     } catch (std::exception& e) {
93209       {
93210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93211       };
93212     } catch (Dali::DaliException e) {
93213       {
93214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93215       };
93216     } catch (...) {
93217       {
93218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93219       };
93220     }
93221   }
93222
93223 }
93224
93225
93226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
93227   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93228   int arg2 ;
93229   int arg3 ;
93230
93231   arg1 = (std::vector< unsigned int > *)jarg1;
93232   arg2 = (int)jarg2;
93233   arg3 = (int)jarg3;
93234   {
93235     try {
93236       try {
93237         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
93238       }
93239       catch(std::out_of_range &_e) {
93240         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93241         return ;
93242       }
93243       catch(std::invalid_argument &_e) {
93244         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93245         return ;
93246       }
93247
93248     } catch (std::out_of_range& e) {
93249       {
93250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93251       };
93252     } catch (std::exception& e) {
93253       {
93254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93255       };
93256     } catch (Dali::DaliException e) {
93257       {
93258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93259       };
93260     } catch (...) {
93261       {
93262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93263       };
93264     }
93265   }
93266
93267 }
93268
93269
93270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
93271   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93272   int arg2 ;
93273   std::vector< unsigned int > *arg3 = 0 ;
93274
93275   arg1 = (std::vector< unsigned int > *)jarg1;
93276   arg2 = (int)jarg2;
93277   arg3 = (std::vector< unsigned int > *)jarg3;
93278   if (!arg3) {
93279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93280     return ;
93281   }
93282   {
93283     try {
93284       try {
93285         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
93286       }
93287       catch(std::out_of_range &_e) {
93288         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93289         return ;
93290       }
93291
93292     } catch (std::out_of_range& e) {
93293       {
93294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93295       };
93296     } catch (std::exception& e) {
93297       {
93298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93299       };
93300     } catch (Dali::DaliException e) {
93301       {
93302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93303       };
93304     } catch (...) {
93305       {
93306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93307       };
93308     }
93309   }
93310
93311 }
93312
93313
93314 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
93315   unsigned int jresult ;
93316   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93317   unsigned int *arg2 = 0 ;
93318   unsigned int temp2 ;
93319   bool result;
93320
93321   arg1 = (std::vector< unsigned int > *)jarg1;
93322   temp2 = (unsigned int)jarg2;
93323   arg2 = &temp2;
93324   {
93325     try {
93326       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
93327     } catch (std::out_of_range& e) {
93328       {
93329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93330       };
93331     } catch (std::exception& e) {
93332       {
93333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93334       };
93335     } catch (Dali::DaliException e) {
93336       {
93337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93338       };
93339     } catch (...) {
93340       {
93341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93342       };
93343     }
93344   }
93345
93346   jresult = result;
93347   return jresult;
93348 }
93349
93350
93351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
93352   int jresult ;
93353   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93354   unsigned int *arg2 = 0 ;
93355   unsigned int temp2 ;
93356   int result;
93357
93358   arg1 = (std::vector< unsigned int > *)jarg1;
93359   temp2 = (unsigned int)jarg2;
93360   arg2 = &temp2;
93361   {
93362     try {
93363       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
93364     } catch (std::out_of_range& e) {
93365       {
93366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93367       };
93368     } catch (std::exception& e) {
93369       {
93370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93371       };
93372     } catch (Dali::DaliException e) {
93373       {
93374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93375       };
93376     } catch (...) {
93377       {
93378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93379       };
93380     }
93381   }
93382
93383   jresult = result;
93384   return jresult;
93385 }
93386
93387
93388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
93389   int jresult ;
93390   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93391   unsigned int *arg2 = 0 ;
93392   unsigned int temp2 ;
93393   int result;
93394
93395   arg1 = (std::vector< unsigned int > *)jarg1;
93396   temp2 = (unsigned int)jarg2;
93397   arg2 = &temp2;
93398   {
93399     try {
93400       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
93401     } catch (std::out_of_range& e) {
93402       {
93403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93404       };
93405     } catch (std::exception& e) {
93406       {
93407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93408       };
93409     } catch (Dali::DaliException e) {
93410       {
93411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93412       };
93413     } catch (...) {
93414       {
93415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93416       };
93417     }
93418   }
93419
93420   jresult = result;
93421   return jresult;
93422 }
93423
93424
93425 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
93426   unsigned int jresult ;
93427   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93428   unsigned int *arg2 = 0 ;
93429   unsigned int temp2 ;
93430   bool result;
93431
93432   arg1 = (std::vector< unsigned int > *)jarg1;
93433   temp2 = (unsigned int)jarg2;
93434   arg2 = &temp2;
93435   {
93436     try {
93437       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
93438     } catch (std::out_of_range& e) {
93439       {
93440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93441       };
93442     } catch (std::exception& e) {
93443       {
93444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93445       };
93446     } catch (Dali::DaliException e) {
93447       {
93448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93449       };
93450     } catch (...) {
93451       {
93452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93453       };
93454     }
93455   }
93456
93457   jresult = result;
93458   return jresult;
93459 }
93460
93461
93462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
93463   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93464
93465   arg1 = (std::vector< unsigned int > *)jarg1;
93466   {
93467     try {
93468       delete arg1;
93469     } catch (std::out_of_range& e) {
93470       {
93471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93472       };
93473     } catch (std::exception& e) {
93474       {
93475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93476       };
93477     } catch (Dali::DaliException e) {
93478       {
93479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93480       };
93481     } catch (...) {
93482       {
93483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93484       };
93485     }
93486   }
93487
93488 }
93489
93490
93491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
93492   void * jresult ;
93493   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93494
93495   {
93496     try {
93497       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
93498     } catch (std::out_of_range& e) {
93499       {
93500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93501       };
93502     } catch (std::exception& e) {
93503       {
93504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93505       };
93506     } catch (Dali::DaliException e) {
93507       {
93508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93509       };
93510     } catch (...) {
93511       {
93512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93513       };
93514     }
93515   }
93516
93517   jresult = (void *)result;
93518   return jresult;
93519 }
93520
93521
93522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
93523   void * jresult ;
93524   unsigned int arg1 ;
93525   Dali::Actor arg2 ;
93526   Dali::Actor *argp2 ;
93527   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93528
93529   arg1 = (unsigned int)jarg1;
93530   argp2 = (Dali::Actor *)jarg2;
93531   if (!argp2) {
93532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
93533     return 0;
93534   }
93535   arg2 = *argp2;
93536   {
93537     try {
93538       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
93539     } catch (std::out_of_range& e) {
93540       {
93541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93542       };
93543     } catch (std::exception& e) {
93544       {
93545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93546       };
93547     } catch (Dali::DaliException e) {
93548       {
93549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93550       };
93551     } catch (...) {
93552       {
93553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93554       };
93555     }
93556   }
93557
93558   jresult = (void *)result;
93559   return jresult;
93560 }
93561
93562
93563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
93564   void * jresult ;
93565   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
93566   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93567
93568   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93569   if (!arg1) {
93570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93571     return 0;
93572   }
93573   {
93574     try {
93575       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
93576     } catch (std::out_of_range& e) {
93577       {
93578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93579       };
93580     } catch (std::exception& e) {
93581       {
93582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93583       };
93584     } catch (Dali::DaliException e) {
93585       {
93586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93587       };
93588     } catch (...) {
93589       {
93590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93591       };
93592     }
93593   }
93594
93595   jresult = (void *)result;
93596   return jresult;
93597 }
93598
93599
93600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
93601   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93602   unsigned int arg2 ;
93603
93604   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93605   arg2 = (unsigned int)jarg2;
93606   if (arg1) (arg1)->first = arg2;
93607 }
93608
93609
93610 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
93611   unsigned int jresult ;
93612   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93613   unsigned int result;
93614
93615   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93616   result = (unsigned int) ((arg1)->first);
93617   jresult = result;
93618   return jresult;
93619 }
93620
93621
93622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
93623   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93624   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
93625
93626   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93627   arg2 = (Dali::Actor *)jarg2;
93628   if (arg1) (arg1)->second = *arg2;
93629 }
93630
93631
93632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
93633   void * jresult ;
93634   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93635   Dali::Actor *result = 0 ;
93636
93637   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93638   result = (Dali::Actor *)& ((arg1)->second);
93639   jresult = (void *)result;
93640   return jresult;
93641 }
93642
93643
93644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
93645   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93646
93647   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93648   {
93649     try {
93650       delete arg1;
93651     } catch (std::out_of_range& e) {
93652       {
93653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93654       };
93655     } catch (std::exception& e) {
93656       {
93657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93658       };
93659     } catch (Dali::DaliException e) {
93660       {
93661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93662       };
93663     } catch (...) {
93664       {
93665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93666       };
93667     }
93668   }
93669
93670 }
93671
93672
93673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
93674   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93675
93676   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93677   {
93678     try {
93679       (arg1)->clear();
93680     } catch (std::out_of_range& e) {
93681       {
93682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93683       };
93684     } catch (std::exception& e) {
93685       {
93686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93687       };
93688     } catch (Dali::DaliException e) {
93689       {
93690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93691       };
93692     } catch (...) {
93693       {
93694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93695       };
93696     }
93697   }
93698
93699 }
93700
93701
93702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
93703   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93704   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
93705
93706   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93707   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
93708   if (!arg2) {
93709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93710     return ;
93711   }
93712   {
93713     try {
93714       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
93715     } catch (std::out_of_range& e) {
93716       {
93717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93718       };
93719     } catch (std::exception& e) {
93720       {
93721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93722       };
93723     } catch (Dali::DaliException e) {
93724       {
93725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93726       };
93727     } catch (...) {
93728       {
93729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93730       };
93731     }
93732   }
93733
93734 }
93735
93736
93737 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
93738   unsigned long jresult ;
93739   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93740   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
93741
93742   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93743   {
93744     try {
93745       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
93746     } catch (std::out_of_range& e) {
93747       {
93748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93749       };
93750     } catch (std::exception& e) {
93751       {
93752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93753       };
93754     } catch (Dali::DaliException e) {
93755       {
93756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93757       };
93758     } catch (...) {
93759       {
93760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93761       };
93762     }
93763   }
93764
93765   jresult = (unsigned long)result;
93766   return jresult;
93767 }
93768
93769
93770 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
93771   unsigned long jresult ;
93772   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93773   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
93774
93775   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93776   {
93777     try {
93778       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
93779     } catch (std::out_of_range& e) {
93780       {
93781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93782       };
93783     } catch (std::exception& e) {
93784       {
93785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93786       };
93787     } catch (Dali::DaliException e) {
93788       {
93789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93790       };
93791     } catch (...) {
93792       {
93793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93794       };
93795     }
93796   }
93797
93798   jresult = (unsigned long)result;
93799   return jresult;
93800 }
93801
93802
93803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
93804   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93805   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
93806
93807   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93808   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
93809   {
93810     try {
93811       (arg1)->reserve(arg2);
93812     } catch (std::out_of_range& e) {
93813       {
93814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93815       };
93816     } catch (std::exception& e) {
93817       {
93818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93819       };
93820     } catch (Dali::DaliException e) {
93821       {
93822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93823       };
93824     } catch (...) {
93825       {
93826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93827       };
93828     }
93829   }
93830
93831 }
93832
93833
93834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
93835   void * jresult ;
93836   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93837
93838   {
93839     try {
93840       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
93841     } catch (std::out_of_range& e) {
93842       {
93843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93844       };
93845     } catch (std::exception& e) {
93846       {
93847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93848       };
93849     } catch (Dali::DaliException e) {
93850       {
93851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93852       };
93853     } catch (...) {
93854       {
93855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93856       };
93857     }
93858   }
93859
93860   jresult = (void *)result;
93861   return jresult;
93862 }
93863
93864
93865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
93866   void * jresult ;
93867   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
93868   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93869
93870   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93871   if (!arg1) {
93872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93873     return 0;
93874   }
93875   {
93876     try {
93877       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);
93878     } catch (std::out_of_range& e) {
93879       {
93880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93881       };
93882     } catch (std::exception& e) {
93883       {
93884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93885       };
93886     } catch (Dali::DaliException e) {
93887       {
93888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93889       };
93890     } catch (...) {
93891       {
93892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93893       };
93894     }
93895   }
93896
93897   jresult = (void *)result;
93898   return jresult;
93899 }
93900
93901
93902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
93903   void * jresult ;
93904   int arg1 ;
93905   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93906
93907   arg1 = (int)jarg1;
93908   {
93909     try {
93910       try {
93911         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);
93912       }
93913       catch(std::out_of_range &_e) {
93914         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93915         return 0;
93916       }
93917
93918     } catch (std::out_of_range& e) {
93919       {
93920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93921       };
93922     } catch (std::exception& e) {
93923       {
93924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93925       };
93926     } catch (Dali::DaliException e) {
93927       {
93928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93929       };
93930     } catch (...) {
93931       {
93932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93933       };
93934     }
93935   }
93936
93937   jresult = (void *)result;
93938   return jresult;
93939 }
93940
93941
93942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
93943   void * jresult ;
93944   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93945   int arg2 ;
93946   std::pair< unsigned int,Dali::Actor > result;
93947
93948   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93949   arg2 = (int)jarg2;
93950   {
93951     try {
93952       try {
93953         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
93954       }
93955       catch(std::out_of_range &_e) {
93956         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93957         return 0;
93958       }
93959
93960     } catch (std::out_of_range& e) {
93961       {
93962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93963       };
93964     } catch (std::exception& e) {
93965       {
93966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93967       };
93968     } catch (Dali::DaliException e) {
93969       {
93970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93971       };
93972     } catch (...) {
93973       {
93974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93975       };
93976     }
93977   }
93978
93979   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
93980   return jresult;
93981 }
93982
93983
93984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
93985   void * jresult ;
93986   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93987   int arg2 ;
93988   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93989
93990   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93991   arg2 = (int)jarg2;
93992   {
93993     try {
93994       try {
93995         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
93996       }
93997       catch(std::out_of_range &_e) {
93998         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93999         return 0;
94000       }
94001
94002     } catch (std::out_of_range& e) {
94003       {
94004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94005       };
94006     } catch (std::exception& e) {
94007       {
94008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94009       };
94010     } catch (Dali::DaliException e) {
94011       {
94012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94013       };
94014     } catch (...) {
94015       {
94016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94017       };
94018     }
94019   }
94020
94021   jresult = (void *)result;
94022   return jresult;
94023 }
94024
94025
94026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
94027   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94028   int arg2 ;
94029   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
94030
94031   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94032   arg2 = (int)jarg2;
94033   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
94034   if (!arg3) {
94035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94036     return ;
94037   }
94038   {
94039     try {
94040       try {
94041         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);
94042       }
94043       catch(std::out_of_range &_e) {
94044         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94045         return ;
94046       }
94047
94048     } catch (std::out_of_range& e) {
94049       {
94050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94051       };
94052     } catch (std::exception& e) {
94053       {
94054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94055       };
94056     } catch (Dali::DaliException e) {
94057       {
94058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94059       };
94060     } catch (...) {
94061       {
94062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94063       };
94064     }
94065   }
94066
94067 }
94068
94069
94070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
94071   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94072   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
94073
94074   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94075   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
94076   if (!arg2) {
94077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94078     return ;
94079   }
94080   {
94081     try {
94082       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);
94083     } catch (std::out_of_range& e) {
94084       {
94085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94086       };
94087     } catch (std::exception& e) {
94088       {
94089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94090       };
94091     } catch (Dali::DaliException e) {
94092       {
94093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94094       };
94095     } catch (...) {
94096       {
94097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94098       };
94099     }
94100   }
94101
94102 }
94103
94104
94105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
94106   void * jresult ;
94107   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94108   int arg2 ;
94109   int arg3 ;
94110   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94111
94112   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94113   arg2 = (int)jarg2;
94114   arg3 = (int)jarg3;
94115   {
94116     try {
94117       try {
94118         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);
94119       }
94120       catch(std::out_of_range &_e) {
94121         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94122         return 0;
94123       }
94124       catch(std::invalid_argument &_e) {
94125         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94126         return 0;
94127       }
94128
94129     } catch (std::out_of_range& e) {
94130       {
94131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94132       };
94133     } catch (std::exception& e) {
94134       {
94135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94136       };
94137     } catch (Dali::DaliException e) {
94138       {
94139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94140       };
94141     } catch (...) {
94142       {
94143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94144       };
94145     }
94146   }
94147
94148   jresult = (void *)result;
94149   return jresult;
94150 }
94151
94152
94153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
94154   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94155   int arg2 ;
94156   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
94157
94158   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94159   arg2 = (int)jarg2;
94160   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
94161   if (!arg3) {
94162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94163     return ;
94164   }
94165   {
94166     try {
94167       try {
94168         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);
94169       }
94170       catch(std::out_of_range &_e) {
94171         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94172         return ;
94173       }
94174
94175     } catch (std::out_of_range& e) {
94176       {
94177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94178       };
94179     } catch (std::exception& e) {
94180       {
94181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94182       };
94183     } catch (Dali::DaliException e) {
94184       {
94185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94186       };
94187     } catch (...) {
94188       {
94189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94190       };
94191     }
94192   }
94193
94194 }
94195
94196
94197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
94198   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94199   int arg2 ;
94200   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94201
94202   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94203   arg2 = (int)jarg2;
94204   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94205   if (!arg3) {
94206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94207     return ;
94208   }
94209   {
94210     try {
94211       try {
94212         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);
94213       }
94214       catch(std::out_of_range &_e) {
94215         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94216         return ;
94217       }
94218
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_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
94242   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94243   int arg2 ;
94244
94245   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94246   arg2 = (int)jarg2;
94247   {
94248     try {
94249       try {
94250         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
94251       }
94252       catch(std::out_of_range &_e) {
94253         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94254         return ;
94255       }
94256
94257     } catch (std::out_of_range& e) {
94258       {
94259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94260       };
94261     } catch (std::exception& e) {
94262       {
94263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94264       };
94265     } catch (Dali::DaliException e) {
94266       {
94267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94268       };
94269     } catch (...) {
94270       {
94271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94272       };
94273     }
94274   }
94275
94276 }
94277
94278
94279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
94280   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94281   int arg2 ;
94282   int arg3 ;
94283
94284   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94285   arg2 = (int)jarg2;
94286   arg3 = (int)jarg3;
94287   {
94288     try {
94289       try {
94290         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
94291       }
94292       catch(std::out_of_range &_e) {
94293         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94294         return ;
94295       }
94296       catch(std::invalid_argument &_e) {
94297         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94298         return ;
94299       }
94300
94301     } catch (std::out_of_range& e) {
94302       {
94303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94304       };
94305     } catch (std::exception& e) {
94306       {
94307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94308       };
94309     } catch (Dali::DaliException e) {
94310       {
94311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94312       };
94313     } catch (...) {
94314       {
94315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94316       };
94317     }
94318   }
94319
94320 }
94321
94322
94323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
94324   void * jresult ;
94325   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
94326   int arg2 ;
94327   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94328
94329   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94330   if (!arg1) {
94331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94332     return 0;
94333   }
94334   arg2 = (int)jarg2;
94335   {
94336     try {
94337       try {
94338         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);
94339       }
94340       catch(std::out_of_range &_e) {
94341         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94342         return 0;
94343       }
94344
94345     } catch (std::out_of_range& e) {
94346       {
94347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94348       };
94349     } catch (std::exception& e) {
94350       {
94351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94352       };
94353     } catch (Dali::DaliException e) {
94354       {
94355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94356       };
94357     } catch (...) {
94358       {
94359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94360       };
94361     }
94362   }
94363
94364   jresult = (void *)result;
94365   return jresult;
94366 }
94367
94368
94369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
94370   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94371
94372   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94373   {
94374     try {
94375       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
94376     } catch (std::out_of_range& e) {
94377       {
94378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94379       };
94380     } catch (std::exception& e) {
94381       {
94382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94383       };
94384     } catch (Dali::DaliException e) {
94385       {
94386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94387       };
94388     } catch (...) {
94389       {
94390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94391       };
94392     }
94393   }
94394
94395 }
94396
94397
94398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
94399   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94400   int arg2 ;
94401   int arg3 ;
94402
94403   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94404   arg2 = (int)jarg2;
94405   arg3 = (int)jarg3;
94406   {
94407     try {
94408       try {
94409         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
94410       }
94411       catch(std::out_of_range &_e) {
94412         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94413         return ;
94414       }
94415       catch(std::invalid_argument &_e) {
94416         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94417         return ;
94418       }
94419
94420     } catch (std::out_of_range& e) {
94421       {
94422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94423       };
94424     } catch (std::exception& e) {
94425       {
94426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94427       };
94428     } catch (Dali::DaliException e) {
94429       {
94430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94431       };
94432     } catch (...) {
94433       {
94434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94435       };
94436     }
94437   }
94438
94439 }
94440
94441
94442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
94443   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94444   int arg2 ;
94445   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94446
94447   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94448   arg2 = (int)jarg2;
94449   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94450   if (!arg3) {
94451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94452     return ;
94453   }
94454   {
94455     try {
94456       try {
94457         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);
94458       }
94459       catch(std::out_of_range &_e) {
94460         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94461         return ;
94462       }
94463
94464     } catch (std::out_of_range& e) {
94465       {
94466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94467       };
94468     } catch (std::exception& e) {
94469       {
94470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94471       };
94472     } catch (Dali::DaliException e) {
94473       {
94474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94475       };
94476     } catch (...) {
94477       {
94478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94479       };
94480     }
94481   }
94482
94483 }
94484
94485
94486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
94487   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94488
94489   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94490   {
94491     try {
94492       delete arg1;
94493     } catch (std::out_of_range& e) {
94494       {
94495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94496       };
94497     } catch (std::exception& e) {
94498       {
94499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94500       };
94501     } catch (Dali::DaliException e) {
94502       {
94503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94504       };
94505     } catch (...) {
94506       {
94507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94508       };
94509     }
94510   }
94511
94512 }
94513
94514
94515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
94516   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94517
94518   arg1 = (std::vector< Dali::Actor > *)jarg1;
94519   {
94520     try {
94521       (arg1)->clear();
94522     } catch (std::out_of_range& e) {
94523       {
94524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94525       };
94526     } catch (std::exception& e) {
94527       {
94528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94529       };
94530     } catch (Dali::DaliException e) {
94531       {
94532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94533       };
94534     } catch (...) {
94535       {
94536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94537       };
94538     }
94539   }
94540
94541 }
94542
94543
94544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
94545   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94546   Dali::Actor *arg2 = 0 ;
94547
94548   arg1 = (std::vector< Dali::Actor > *)jarg1;
94549   arg2 = (Dali::Actor *)jarg2;
94550   if (!arg2) {
94551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94552     return ;
94553   }
94554   {
94555     try {
94556       (arg1)->push_back((Dali::Actor const &)*arg2);
94557     } catch (std::out_of_range& e) {
94558       {
94559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94560       };
94561     } catch (std::exception& e) {
94562       {
94563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94564       };
94565     } catch (Dali::DaliException e) {
94566       {
94567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94568       };
94569     } catch (...) {
94570       {
94571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94572       };
94573     }
94574   }
94575
94576 }
94577
94578
94579 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
94580   unsigned long jresult ;
94581   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94582   std::vector< Dali::Actor >::size_type result;
94583
94584   arg1 = (std::vector< Dali::Actor > *)jarg1;
94585   {
94586     try {
94587       result = ((std::vector< Dali::Actor > const *)arg1)->size();
94588     } catch (std::out_of_range& e) {
94589       {
94590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94591       };
94592     } catch (std::exception& e) {
94593       {
94594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94595       };
94596     } catch (Dali::DaliException e) {
94597       {
94598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94599       };
94600     } catch (...) {
94601       {
94602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94603       };
94604     }
94605   }
94606
94607   jresult = (unsigned long)result;
94608   return jresult;
94609 }
94610
94611
94612 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
94613   unsigned long jresult ;
94614   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94615   std::vector< Dali::Actor >::size_type result;
94616
94617   arg1 = (std::vector< Dali::Actor > *)jarg1;
94618   {
94619     try {
94620       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
94621     } catch (std::out_of_range& e) {
94622       {
94623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94624       };
94625     } catch (std::exception& e) {
94626       {
94627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94628       };
94629     } catch (Dali::DaliException e) {
94630       {
94631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94632       };
94633     } catch (...) {
94634       {
94635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94636       };
94637     }
94638   }
94639
94640   jresult = (unsigned long)result;
94641   return jresult;
94642 }
94643
94644
94645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
94646   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94647   std::vector< Dali::Actor >::size_type arg2 ;
94648
94649   arg1 = (std::vector< Dali::Actor > *)jarg1;
94650   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
94651   {
94652     try {
94653       (arg1)->reserve(arg2);
94654     } catch (std::out_of_range& e) {
94655       {
94656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94657       };
94658     } catch (std::exception& e) {
94659       {
94660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94661       };
94662     } catch (Dali::DaliException e) {
94663       {
94664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94665       };
94666     } catch (...) {
94667       {
94668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94669       };
94670     }
94671   }
94672
94673 }
94674
94675
94676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
94677   void * jresult ;
94678   std::vector< Dali::Actor > *result = 0 ;
94679
94680   {
94681     try {
94682       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
94683     } catch (std::out_of_range& e) {
94684       {
94685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94686       };
94687     } catch (std::exception& e) {
94688       {
94689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94690       };
94691     } catch (Dali::DaliException e) {
94692       {
94693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94694       };
94695     } catch (...) {
94696       {
94697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94698       };
94699     }
94700   }
94701
94702   jresult = (void *)result;
94703   return jresult;
94704 }
94705
94706
94707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
94708   void * jresult ;
94709   std::vector< Dali::Actor > *arg1 = 0 ;
94710   std::vector< Dali::Actor > *result = 0 ;
94711
94712   arg1 = (std::vector< Dali::Actor > *)jarg1;
94713   if (!arg1) {
94714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94715     return 0;
94716   }
94717   {
94718     try {
94719       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
94720     } catch (std::out_of_range& e) {
94721       {
94722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94723       };
94724     } catch (std::exception& e) {
94725       {
94726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94727       };
94728     } catch (Dali::DaliException e) {
94729       {
94730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94731       };
94732     } catch (...) {
94733       {
94734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94735       };
94736     }
94737   }
94738
94739   jresult = (void *)result;
94740   return jresult;
94741 }
94742
94743
94744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
94745   void * jresult ;
94746   int arg1 ;
94747   std::vector< Dali::Actor > *result = 0 ;
94748
94749   arg1 = (int)jarg1;
94750   {
94751     try {
94752       try {
94753         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
94754       }
94755       catch(std::out_of_range &_e) {
94756         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94757         return 0;
94758       }
94759
94760     } catch (std::out_of_range& e) {
94761       {
94762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94763       };
94764     } catch (std::exception& e) {
94765       {
94766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94767       };
94768     } catch (Dali::DaliException e) {
94769       {
94770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94771       };
94772     } catch (...) {
94773       {
94774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94775       };
94776     }
94777   }
94778
94779   jresult = (void *)result;
94780   return jresult;
94781 }
94782
94783
94784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
94785   void * jresult ;
94786   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94787   int arg2 ;
94788   Dali::Actor result;
94789
94790   arg1 = (std::vector< Dali::Actor > *)jarg1;
94791   arg2 = (int)jarg2;
94792   {
94793     try {
94794       try {
94795         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
94796       }
94797       catch(std::out_of_range &_e) {
94798         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94799         return 0;
94800       }
94801
94802     } catch (std::out_of_range& e) {
94803       {
94804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94805       };
94806     } catch (std::exception& e) {
94807       {
94808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94809       };
94810     } catch (Dali::DaliException e) {
94811       {
94812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94813       };
94814     } catch (...) {
94815       {
94816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94817       };
94818     }
94819   }
94820
94821   jresult = new Dali::Actor((const Dali::Actor &)result);
94822   return jresult;
94823 }
94824
94825
94826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
94827   void * jresult ;
94828   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94829   int arg2 ;
94830   Dali::Actor *result = 0 ;
94831
94832   arg1 = (std::vector< Dali::Actor > *)jarg1;
94833   arg2 = (int)jarg2;
94834   {
94835     try {
94836       try {
94837         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
94838       }
94839       catch(std::out_of_range &_e) {
94840         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94841         return 0;
94842       }
94843
94844     } catch (std::out_of_range& e) {
94845       {
94846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94847       };
94848     } catch (std::exception& e) {
94849       {
94850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94851       };
94852     } catch (Dali::DaliException e) {
94853       {
94854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94855       };
94856     } catch (...) {
94857       {
94858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94859       };
94860     }
94861   }
94862
94863   jresult = (void *)result;
94864   return jresult;
94865 }
94866
94867
94868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
94869   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94870   int arg2 ;
94871   Dali::Actor *arg3 = 0 ;
94872
94873   arg1 = (std::vector< Dali::Actor > *)jarg1;
94874   arg2 = (int)jarg2;
94875   arg3 = (Dali::Actor *)jarg3;
94876   if (!arg3) {
94877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94878     return ;
94879   }
94880   {
94881     try {
94882       try {
94883         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
94884       }
94885       catch(std::out_of_range &_e) {
94886         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94887         return ;
94888       }
94889
94890     } catch (std::out_of_range& e) {
94891       {
94892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94893       };
94894     } catch (std::exception& e) {
94895       {
94896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94897       };
94898     } catch (Dali::DaliException e) {
94899       {
94900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94901       };
94902     } catch (...) {
94903       {
94904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94905       };
94906     }
94907   }
94908
94909 }
94910
94911
94912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
94913   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94914   std::vector< Dali::Actor > *arg2 = 0 ;
94915
94916   arg1 = (std::vector< Dali::Actor > *)jarg1;
94917   arg2 = (std::vector< Dali::Actor > *)jarg2;
94918   if (!arg2) {
94919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94920     return ;
94921   }
94922   {
94923     try {
94924       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
94925     } catch (std::out_of_range& e) {
94926       {
94927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94928       };
94929     } catch (std::exception& e) {
94930       {
94931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94932       };
94933     } catch (Dali::DaliException e) {
94934       {
94935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94936       };
94937     } catch (...) {
94938       {
94939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94940       };
94941     }
94942   }
94943
94944 }
94945
94946
94947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
94948   void * jresult ;
94949   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94950   int arg2 ;
94951   int arg3 ;
94952   std::vector< Dali::Actor > *result = 0 ;
94953
94954   arg1 = (std::vector< Dali::Actor > *)jarg1;
94955   arg2 = (int)jarg2;
94956   arg3 = (int)jarg3;
94957   {
94958     try {
94959       try {
94960         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
94961       }
94962       catch(std::out_of_range &_e) {
94963         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94964         return 0;
94965       }
94966       catch(std::invalid_argument &_e) {
94967         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94968         return 0;
94969       }
94970
94971     } catch (std::out_of_range& e) {
94972       {
94973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94974       };
94975     } catch (std::exception& e) {
94976       {
94977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94978       };
94979     } catch (Dali::DaliException e) {
94980       {
94981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94982       };
94983     } catch (...) {
94984       {
94985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94986       };
94987     }
94988   }
94989
94990   jresult = (void *)result;
94991   return jresult;
94992 }
94993
94994
94995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
94996   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94997   int arg2 ;
94998   Dali::Actor *arg3 = 0 ;
94999
95000   arg1 = (std::vector< Dali::Actor > *)jarg1;
95001   arg2 = (int)jarg2;
95002   arg3 = (Dali::Actor *)jarg3;
95003   if (!arg3) {
95004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95005     return ;
95006   }
95007   {
95008     try {
95009       try {
95010         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
95011       }
95012       catch(std::out_of_range &_e) {
95013         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95014         return ;
95015       }
95016
95017     } catch (std::out_of_range& e) {
95018       {
95019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95020       };
95021     } catch (std::exception& e) {
95022       {
95023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95024       };
95025     } catch (Dali::DaliException e) {
95026       {
95027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95028       };
95029     } catch (...) {
95030       {
95031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95032       };
95033     }
95034   }
95035
95036 }
95037
95038
95039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
95040   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95041   int arg2 ;
95042   std::vector< Dali::Actor > *arg3 = 0 ;
95043
95044   arg1 = (std::vector< Dali::Actor > *)jarg1;
95045   arg2 = (int)jarg2;
95046   arg3 = (std::vector< Dali::Actor > *)jarg3;
95047   if (!arg3) {
95048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95049     return ;
95050   }
95051   {
95052     try {
95053       try {
95054         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
95055       }
95056       catch(std::out_of_range &_e) {
95057         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95058         return ;
95059       }
95060
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_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
95084   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95085   int arg2 ;
95086
95087   arg1 = (std::vector< Dali::Actor > *)jarg1;
95088   arg2 = (int)jarg2;
95089   {
95090     try {
95091       try {
95092         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
95093       }
95094       catch(std::out_of_range &_e) {
95095         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95096         return ;
95097       }
95098
95099     } catch (std::out_of_range& e) {
95100       {
95101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95102       };
95103     } catch (std::exception& e) {
95104       {
95105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95106       };
95107     } catch (Dali::DaliException e) {
95108       {
95109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95110       };
95111     } catch (...) {
95112       {
95113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95114       };
95115     }
95116   }
95117
95118 }
95119
95120
95121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
95122   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95123   int arg2 ;
95124   int arg3 ;
95125
95126   arg1 = (std::vector< Dali::Actor > *)jarg1;
95127   arg2 = (int)jarg2;
95128   arg3 = (int)jarg3;
95129   {
95130     try {
95131       try {
95132         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
95133       }
95134       catch(std::out_of_range &_e) {
95135         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95136         return ;
95137       }
95138       catch(std::invalid_argument &_e) {
95139         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95140         return ;
95141       }
95142
95143     } catch (std::out_of_range& e) {
95144       {
95145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95146       };
95147     } catch (std::exception& e) {
95148       {
95149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95150       };
95151     } catch (Dali::DaliException e) {
95152       {
95153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95154       };
95155     } catch (...) {
95156       {
95157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95158       };
95159     }
95160   }
95161
95162 }
95163
95164
95165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
95166   void * jresult ;
95167   Dali::Actor *arg1 = 0 ;
95168   int arg2 ;
95169   std::vector< Dali::Actor > *result = 0 ;
95170
95171   arg1 = (Dali::Actor *)jarg1;
95172   if (!arg1) {
95173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95174     return 0;
95175   }
95176   arg2 = (int)jarg2;
95177   {
95178     try {
95179       try {
95180         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
95181       }
95182       catch(std::out_of_range &_e) {
95183         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95184         return 0;
95185       }
95186
95187     } catch (std::out_of_range& e) {
95188       {
95189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95190       };
95191     } catch (std::exception& e) {
95192       {
95193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95194       };
95195     } catch (Dali::DaliException e) {
95196       {
95197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95198       };
95199     } catch (...) {
95200       {
95201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95202       };
95203     }
95204   }
95205
95206   jresult = (void *)result;
95207   return jresult;
95208 }
95209
95210
95211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
95212   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95213
95214   arg1 = (std::vector< Dali::Actor > *)jarg1;
95215   {
95216     try {
95217       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
95218     } catch (std::out_of_range& e) {
95219       {
95220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95221       };
95222     } catch (std::exception& e) {
95223       {
95224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95225       };
95226     } catch (Dali::DaliException e) {
95227       {
95228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95229       };
95230     } catch (...) {
95231       {
95232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95233       };
95234     }
95235   }
95236
95237 }
95238
95239
95240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
95241   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95242   int arg2 ;
95243   int arg3 ;
95244
95245   arg1 = (std::vector< Dali::Actor > *)jarg1;
95246   arg2 = (int)jarg2;
95247   arg3 = (int)jarg3;
95248   {
95249     try {
95250       try {
95251         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
95252       }
95253       catch(std::out_of_range &_e) {
95254         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95255         return ;
95256       }
95257       catch(std::invalid_argument &_e) {
95258         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95259         return ;
95260       }
95261
95262     } catch (std::out_of_range& e) {
95263       {
95264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95265       };
95266     } catch (std::exception& e) {
95267       {
95268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95269       };
95270     } catch (Dali::DaliException e) {
95271       {
95272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95273       };
95274     } catch (...) {
95275       {
95276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95277       };
95278     }
95279   }
95280
95281 }
95282
95283
95284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
95285   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95286   int arg2 ;
95287   std::vector< Dali::Actor > *arg3 = 0 ;
95288
95289   arg1 = (std::vector< Dali::Actor > *)jarg1;
95290   arg2 = (int)jarg2;
95291   arg3 = (std::vector< Dali::Actor > *)jarg3;
95292   if (!arg3) {
95293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95294     return ;
95295   }
95296   {
95297     try {
95298       try {
95299         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
95300       }
95301       catch(std::out_of_range &_e) {
95302         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95303         return ;
95304       }
95305
95306     } catch (std::out_of_range& e) {
95307       {
95308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95309       };
95310     } catch (std::exception& e) {
95311       {
95312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95313       };
95314     } catch (Dali::DaliException e) {
95315       {
95316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95317       };
95318     } catch (...) {
95319       {
95320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95321       };
95322     }
95323   }
95324
95325 }
95326
95327
95328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
95329   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95330
95331   arg1 = (std::vector< Dali::Actor > *)jarg1;
95332   {
95333     try {
95334       delete arg1;
95335     } catch (std::out_of_range& e) {
95336       {
95337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95338       };
95339     } catch (std::exception& e) {
95340       {
95341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95342       };
95343     } catch (Dali::DaliException e) {
95344       {
95345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95346       };
95347     } catch (...) {
95348       {
95349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95350       };
95351     }
95352   }
95353
95354 }
95355
95356
95357 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
95358   unsigned int jresult ;
95359   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95360   bool result;
95361
95362   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95363   {
95364     try {
95365       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95366     } catch (std::out_of_range& e) {
95367       {
95368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95369       };
95370     } catch (std::exception& e) {
95371       {
95372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95373       };
95374     } catch (Dali::DaliException e) {
95375       {
95376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95377       };
95378     } catch (...) {
95379       {
95380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95381       };
95382     }
95383   }
95384
95385   jresult = result;
95386   return jresult;
95387 }
95388
95389
95390 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
95391   unsigned long jresult ;
95392   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95393   std::size_t result;
95394
95395   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95396   {
95397     try {
95398       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95399     } catch (std::out_of_range& e) {
95400       {
95401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95402       };
95403     } catch (std::exception& e) {
95404       {
95405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95406       };
95407     } catch (Dali::DaliException e) {
95408       {
95409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95410       };
95411     } catch (...) {
95412       {
95413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95414       };
95415     }
95416   }
95417
95418   jresult = (unsigned long)result;
95419   return jresult;
95420 }
95421
95422
95423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
95424   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95425   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95426
95427   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95428   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95429   {
95430     try {
95431       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
95432     } catch (std::out_of_range& e) {
95433       {
95434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95435       };
95436     } catch (std::exception& e) {
95437       {
95438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95439       };
95440     } catch (Dali::DaliException e) {
95441       {
95442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95443       };
95444     } catch (...) {
95445       {
95446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95447       };
95448     }
95449   }
95450
95451 }
95452
95453
95454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
95455   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95456   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95457
95458   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95459   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95460   {
95461     try {
95462       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
95463     } catch (std::out_of_range& e) {
95464       {
95465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95466       };
95467     } catch (std::exception& e) {
95468       {
95469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95470       };
95471     } catch (Dali::DaliException e) {
95472       {
95473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95474       };
95475     } catch (...) {
95476       {
95477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95478       };
95479     }
95480   }
95481
95482 }
95483
95484
95485 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
95486   unsigned int jresult ;
95487   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95488   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
95489   bool result;
95490
95491   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95492   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
95493   if (!arg2) {
95494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
95495     return 0;
95496   }
95497   {
95498     try {
95499       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
95500     } catch (std::out_of_range& e) {
95501       {
95502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95503       };
95504     } catch (std::exception& e) {
95505       {
95506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95507       };
95508     } catch (Dali::DaliException e) {
95509       {
95510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95511       };
95512     } catch (...) {
95513       {
95514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95515       };
95516     }
95517   }
95518
95519   jresult = result;
95520   return jresult;
95521 }
95522
95523
95524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
95525   void * jresult ;
95526   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
95527
95528   {
95529     try {
95530       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
95531     } catch (std::out_of_range& e) {
95532       {
95533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95534       };
95535     } catch (std::exception& e) {
95536       {
95537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95538       };
95539     } catch (Dali::DaliException e) {
95540       {
95541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95542       };
95543     } catch (...) {
95544       {
95545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95546       };
95547     }
95548   }
95549
95550   jresult = (void *)result;
95551   return jresult;
95552 }
95553
95554
95555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
95556   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95557
95558   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95559   {
95560     try {
95561       delete arg1;
95562     } catch (std::out_of_range& e) {
95563       {
95564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95565       };
95566     } catch (std::exception& e) {
95567       {
95568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95569       };
95570     } catch (Dali::DaliException e) {
95571       {
95572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95573       };
95574     } catch (...) {
95575       {
95576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95577       };
95578     }
95579   }
95580
95581 }
95582
95583
95584 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
95585   unsigned int jresult ;
95586   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95587   bool result;
95588
95589   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95590   {
95591     try {
95592       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);
95593     } catch (std::out_of_range& e) {
95594       {
95595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95596       };
95597     } catch (std::exception& e) {
95598       {
95599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95600       };
95601     } catch (Dali::DaliException e) {
95602       {
95603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95604       };
95605     } catch (...) {
95606       {
95607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95608       };
95609     }
95610   }
95611
95612   jresult = result;
95613   return jresult;
95614 }
95615
95616
95617 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
95618   unsigned long jresult ;
95619   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95620   std::size_t result;
95621
95622   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95623   {
95624     try {
95625       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);
95626     } catch (std::out_of_range& e) {
95627       {
95628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95629       };
95630     } catch (std::exception& e) {
95631       {
95632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95633       };
95634     } catch (Dali::DaliException e) {
95635       {
95636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95637       };
95638     } catch (...) {
95639       {
95640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95641       };
95642     }
95643   }
95644
95645   jresult = (unsigned long)result;
95646   return jresult;
95647 }
95648
95649
95650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
95651   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95652   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
95653
95654   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95655   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
95656   {
95657     try {
95658       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
95659     } catch (std::out_of_range& e) {
95660       {
95661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95662       };
95663     } catch (std::exception& e) {
95664       {
95665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95666       };
95667     } catch (Dali::DaliException e) {
95668       {
95669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95670       };
95671     } catch (...) {
95672       {
95673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95674       };
95675     }
95676   }
95677
95678 }
95679
95680
95681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
95682   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95683   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
95684
95685   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95686   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
95687   {
95688     try {
95689       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
95690     } catch (std::out_of_range& e) {
95691       {
95692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95693       };
95694     } catch (std::exception& e) {
95695       {
95696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95697       };
95698     } catch (Dali::DaliException e) {
95699       {
95700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95701       };
95702     } catch (...) {
95703       {
95704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95705       };
95706     }
95707   }
95708
95709 }
95710
95711
95712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
95713   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95714   Dali::Actor arg2 ;
95715   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
95716   Dali::Actor *argp2 ;
95717
95718   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95719   argp2 = (Dali::Actor *)jarg2;
95720   if (!argp2) {
95721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95722     return ;
95723   }
95724   arg2 = *argp2;
95725   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
95726   {
95727     try {
95728       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
95729     } catch (std::out_of_range& e) {
95730       {
95731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95732       };
95733     } catch (std::exception& e) {
95734       {
95735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95736       };
95737     } catch (Dali::DaliException e) {
95738       {
95739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95740       };
95741     } catch (...) {
95742       {
95743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95744       };
95745     }
95746   }
95747
95748 }
95749
95750
95751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
95752   void * jresult ;
95753   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
95754
95755   {
95756     try {
95757       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
95758     } catch (std::out_of_range& e) {
95759       {
95760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95761       };
95762     } catch (std::exception& e) {
95763       {
95764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95765       };
95766     } catch (Dali::DaliException e) {
95767       {
95768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95769       };
95770     } catch (...) {
95771       {
95772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95773       };
95774     }
95775   }
95776
95777   jresult = (void *)result;
95778   return jresult;
95779 }
95780
95781
95782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
95783   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95784
95785   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95786   {
95787     try {
95788       delete arg1;
95789     } catch (std::out_of_range& e) {
95790       {
95791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95792       };
95793     } catch (std::exception& e) {
95794       {
95795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95796       };
95797     } catch (Dali::DaliException e) {
95798       {
95799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95800       };
95801     } catch (...) {
95802       {
95803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95804       };
95805     }
95806   }
95807
95808 }
95809
95810
95811 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
95812   unsigned int jresult ;
95813   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95814   bool result;
95815
95816   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95817   {
95818     try {
95819       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
95820     } catch (std::out_of_range& e) {
95821       {
95822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95823       };
95824     } catch (std::exception& e) {
95825       {
95826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95827       };
95828     } catch (Dali::DaliException e) {
95829       {
95830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95831       };
95832     } catch (...) {
95833       {
95834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95835       };
95836     }
95837   }
95838
95839   jresult = result;
95840   return jresult;
95841 }
95842
95843
95844 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
95845   unsigned long jresult ;
95846   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95847   std::size_t result;
95848
95849   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95850   {
95851     try {
95852       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
95853     } catch (std::out_of_range& e) {
95854       {
95855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95856       };
95857     } catch (std::exception& e) {
95858       {
95859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95860       };
95861     } catch (Dali::DaliException e) {
95862       {
95863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95864       };
95865     } catch (...) {
95866       {
95867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95868       };
95869     }
95870   }
95871
95872   jresult = (unsigned long)result;
95873   return jresult;
95874 }
95875
95876
95877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
95878   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95879   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
95880
95881   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95882   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
95883   {
95884     try {
95885       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
95886     } catch (std::out_of_range& e) {
95887       {
95888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95889       };
95890     } catch (std::exception& e) {
95891       {
95892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95893       };
95894     } catch (Dali::DaliException e) {
95895       {
95896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95897       };
95898     } catch (...) {
95899       {
95900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95901       };
95902     }
95903   }
95904
95905 }
95906
95907
95908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
95909   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95910   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
95911
95912   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95913   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
95914   {
95915     try {
95916       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
95917     } catch (std::out_of_range& e) {
95918       {
95919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95920       };
95921     } catch (std::exception& e) {
95922       {
95923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95924       };
95925     } catch (Dali::DaliException e) {
95926       {
95927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95928       };
95929     } catch (...) {
95930       {
95931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95932       };
95933     }
95934   }
95935
95936 }
95937
95938
95939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
95940   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95941   Dali::Actor arg2 ;
95942   Dali::Actor arg3 ;
95943   Dali::Actor *argp2 ;
95944   Dali::Actor *argp3 ;
95945
95946   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95947   argp2 = (Dali::Actor *)jarg2;
95948   if (!argp2) {
95949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95950     return ;
95951   }
95952   arg2 = *argp2;
95953   argp3 = (Dali::Actor *)jarg3;
95954   if (!argp3) {
95955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95956     return ;
95957   }
95958   arg3 = *argp3;
95959   {
95960     try {
95961       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
95962     } catch (std::out_of_range& e) {
95963       {
95964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95965       };
95966     } catch (std::exception& e) {
95967       {
95968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95969       };
95970     } catch (Dali::DaliException e) {
95971       {
95972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95973       };
95974     } catch (...) {
95975       {
95976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95977       };
95978     }
95979   }
95980
95981 }
95982
95983
95984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
95985   void * jresult ;
95986   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
95987
95988   {
95989     try {
95990       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
95991     } catch (std::out_of_range& e) {
95992       {
95993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95994       };
95995     } catch (std::exception& e) {
95996       {
95997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95998       };
95999     } catch (Dali::DaliException e) {
96000       {
96001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96002       };
96003     } catch (...) {
96004       {
96005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96006       };
96007     }
96008   }
96009
96010   jresult = (void *)result;
96011   return jresult;
96012 }
96013
96014
96015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
96016   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96017
96018   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96019   {
96020     try {
96021       delete arg1;
96022     } catch (std::out_of_range& e) {
96023       {
96024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96025       };
96026     } catch (std::exception& e) {
96027       {
96028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96029       };
96030     } catch (Dali::DaliException e) {
96031       {
96032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96033       };
96034     } catch (...) {
96035       {
96036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96037       };
96038     }
96039   }
96040
96041 }
96042
96043
96044 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
96045   unsigned int jresult ;
96046   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96047   bool result;
96048
96049   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96050   {
96051     try {
96052       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
96053     } catch (std::out_of_range& e) {
96054       {
96055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96056       };
96057     } catch (std::exception& e) {
96058       {
96059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96060       };
96061     } catch (Dali::DaliException e) {
96062       {
96063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96064       };
96065     } catch (...) {
96066       {
96067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96068       };
96069     }
96070   }
96071
96072   jresult = result;
96073   return jresult;
96074 }
96075
96076
96077 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
96078   unsigned long jresult ;
96079   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96080   std::size_t result;
96081
96082   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96083   {
96084     try {
96085       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
96086     } catch (std::out_of_range& e) {
96087       {
96088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96089       };
96090     } catch (std::exception& e) {
96091       {
96092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96093       };
96094     } catch (Dali::DaliException e) {
96095       {
96096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96097       };
96098     } catch (...) {
96099       {
96100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96101       };
96102     }
96103   }
96104
96105   jresult = (unsigned long)result;
96106   return jresult;
96107 }
96108
96109
96110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
96111   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96112   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
96113
96114   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96115   arg2 = (void (*)(Dali::Actor,bool))jarg2;
96116   {
96117     try {
96118       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
96119     } catch (std::out_of_range& e) {
96120       {
96121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96122       };
96123     } catch (std::exception& e) {
96124       {
96125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96126       };
96127     } catch (Dali::DaliException e) {
96128       {
96129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96130       };
96131     } catch (...) {
96132       {
96133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96134       };
96135     }
96136   }
96137
96138 }
96139
96140
96141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96142   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96143   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
96144
96145   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96146   arg2 = (void (*)(Dali::Actor,bool))jarg2;
96147   {
96148     try {
96149       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
96150     } catch (std::out_of_range& e) {
96151       {
96152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96153       };
96154     } catch (std::exception& e) {
96155       {
96156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96157       };
96158     } catch (Dali::DaliException e) {
96159       {
96160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96161       };
96162     } catch (...) {
96163       {
96164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96165       };
96166     }
96167   }
96168
96169 }
96170
96171
96172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
96173   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96174   Dali::Actor arg2 ;
96175   bool arg3 ;
96176   Dali::Actor *argp2 ;
96177
96178   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96179   argp2 = (Dali::Actor *)jarg2;
96180   if (!argp2) {
96181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96182     return ;
96183   }
96184   arg2 = *argp2;
96185   arg3 = jarg3 ? true : false;
96186   {
96187     try {
96188       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
96189     } catch (std::out_of_range& e) {
96190       {
96191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96192       };
96193     } catch (std::exception& e) {
96194       {
96195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96196       };
96197     } catch (Dali::DaliException e) {
96198       {
96199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96200       };
96201     } catch (...) {
96202       {
96203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96204       };
96205     }
96206   }
96207
96208 }
96209
96210
96211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
96212   void * jresult ;
96213   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
96214
96215   {
96216     try {
96217       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
96218     } catch (std::out_of_range& e) {
96219       {
96220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96221       };
96222     } catch (std::exception& e) {
96223       {
96224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96225       };
96226     } catch (Dali::DaliException e) {
96227       {
96228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96229       };
96230     } catch (...) {
96231       {
96232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96233       };
96234     }
96235   }
96236
96237   jresult = (void *)result;
96238   return jresult;
96239 }
96240
96241
96242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
96243   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96244
96245   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96246   {
96247     try {
96248       delete arg1;
96249     } catch (std::out_of_range& e) {
96250       {
96251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96252       };
96253     } catch (std::exception& e) {
96254       {
96255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96256       };
96257     } catch (Dali::DaliException e) {
96258       {
96259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96260       };
96261     } catch (...) {
96262       {
96263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96264       };
96265     }
96266   }
96267
96268 }
96269
96270
96271 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
96272   unsigned int jresult ;
96273   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96274   bool result;
96275
96276   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96277   {
96278     try {
96279       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);
96280     } catch (std::out_of_range& e) {
96281       {
96282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96283       };
96284     } catch (std::exception& e) {
96285       {
96286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96287       };
96288     } catch (Dali::DaliException e) {
96289       {
96290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96291       };
96292     } catch (...) {
96293       {
96294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96295       };
96296     }
96297   }
96298
96299   jresult = result;
96300   return jresult;
96301 }
96302
96303
96304 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
96305   unsigned long jresult ;
96306   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96307   std::size_t result;
96308
96309   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96310   {
96311     try {
96312       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);
96313     } catch (std::out_of_range& e) {
96314       {
96315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96316       };
96317     } catch (std::exception& e) {
96318       {
96319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96320       };
96321     } catch (Dali::DaliException e) {
96322       {
96323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96324       };
96325     } catch (...) {
96326       {
96327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96328       };
96329     }
96330   }
96331
96332   jresult = (unsigned long)result;
96333   return jresult;
96334 }
96335
96336
96337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
96338   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96339   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96340
96341   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96342   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96343   {
96344     try {
96345       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
96346     } catch (std::out_of_range& e) {
96347       {
96348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96349       };
96350     } catch (std::exception& e) {
96351       {
96352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96353       };
96354     } catch (Dali::DaliException e) {
96355       {
96356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96357       };
96358     } catch (...) {
96359       {
96360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96361       };
96362     }
96363   }
96364
96365 }
96366
96367
96368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96369   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96370   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96371
96372   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96373   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96374   {
96375     try {
96376       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
96377     } catch (std::out_of_range& e) {
96378       {
96379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96380       };
96381     } catch (std::exception& e) {
96382       {
96383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96384       };
96385     } catch (Dali::DaliException e) {
96386       {
96387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96388       };
96389     } catch (...) {
96390       {
96391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96392       };
96393     }
96394   }
96395
96396 }
96397
96398
96399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
96400   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96401   Dali::Toolkit::StyleManager arg2 ;
96402   Dali::StyleChange::Type arg3 ;
96403   Dali::Toolkit::StyleManager *argp2 ;
96404
96405   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96406   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
96407   if (!argp2) {
96408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
96409     return ;
96410   }
96411   arg2 = *argp2;
96412   arg3 = (Dali::StyleChange::Type)jarg3;
96413   {
96414     try {
96415       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
96416     } catch (std::out_of_range& e) {
96417       {
96418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96419       };
96420     } catch (std::exception& e) {
96421       {
96422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96423       };
96424     } catch (Dali::DaliException e) {
96425       {
96426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96427       };
96428     } catch (...) {
96429       {
96430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96431       };
96432     }
96433   }
96434
96435 }
96436
96437
96438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
96439   void * jresult ;
96440   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
96441
96442   {
96443     try {
96444       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
96445     } catch (std::out_of_range& e) {
96446       {
96447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96448       };
96449     } catch (std::exception& e) {
96450       {
96451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96452       };
96453     } catch (Dali::DaliException e) {
96454       {
96455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96456       };
96457     } catch (...) {
96458       {
96459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96460       };
96461     }
96462   }
96463
96464   jresult = (void *)result;
96465   return jresult;
96466 }
96467
96468
96469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
96470   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96471
96472   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96473   {
96474     try {
96475       delete arg1;
96476     } catch (std::out_of_range& e) {
96477       {
96478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96479       };
96480     } catch (std::exception& e) {
96481       {
96482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96483       };
96484     } catch (Dali::DaliException e) {
96485       {
96486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96487       };
96488     } catch (...) {
96489       {
96490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96491       };
96492     }
96493   }
96494
96495 }
96496
96497
96498 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
96499   unsigned int jresult ;
96500   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96501   bool result;
96502
96503   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96504   {
96505     try {
96506       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96507     } catch (std::out_of_range& e) {
96508       {
96509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96510       };
96511     } catch (std::exception& e) {
96512       {
96513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96514       };
96515     } catch (Dali::DaliException e) {
96516       {
96517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96518       };
96519     } catch (...) {
96520       {
96521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96522       };
96523     }
96524   }
96525
96526   jresult = result;
96527   return jresult;
96528 }
96529
96530
96531 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
96532   unsigned long jresult ;
96533   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96534   std::size_t result;
96535
96536   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96537   {
96538     try {
96539       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96540     } catch (std::out_of_range& e) {
96541       {
96542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96543       };
96544     } catch (std::exception& e) {
96545       {
96546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96547       };
96548     } catch (Dali::DaliException e) {
96549       {
96550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96551       };
96552     } catch (...) {
96553       {
96554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96555       };
96556     }
96557   }
96558
96559   jresult = (unsigned long)result;
96560   return jresult;
96561 }
96562
96563
96564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
96565   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96566   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96567
96568   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96569   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96570   {
96571     try {
96572       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
96573     } catch (std::out_of_range& e) {
96574       {
96575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96576       };
96577     } catch (std::exception& e) {
96578       {
96579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96580       };
96581     } catch (Dali::DaliException e) {
96582       {
96583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96584       };
96585     } catch (...) {
96586       {
96587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96588       };
96589     }
96590   }
96591
96592 }
96593
96594
96595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
96596   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96597   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96598
96599   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96600   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96601   {
96602     try {
96603       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
96604     } catch (std::out_of_range& e) {
96605       {
96606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96607       };
96608     } catch (std::exception& e) {
96609       {
96610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96611       };
96612     } catch (Dali::DaliException e) {
96613       {
96614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96615       };
96616     } catch (...) {
96617       {
96618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96619       };
96620     }
96621   }
96622
96623 }
96624
96625
96626 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
96627   unsigned int jresult ;
96628   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96629   Dali::Toolkit::Button arg2 ;
96630   Dali::Toolkit::Button *argp2 ;
96631   bool result;
96632
96633   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96634   argp2 = (Dali::Toolkit::Button *)jarg2;
96635   if (!argp2) {
96636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
96637     return 0;
96638   }
96639   arg2 = *argp2;
96640   {
96641     try {
96642       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
96643     } catch (std::out_of_range& e) {
96644       {
96645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96646       };
96647     } catch (std::exception& e) {
96648       {
96649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96650       };
96651     } catch (Dali::DaliException e) {
96652       {
96653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96654       };
96655     } catch (...) {
96656       {
96657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96658       };
96659     }
96660   }
96661
96662   jresult = result;
96663   return jresult;
96664 }
96665
96666
96667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
96668   void * jresult ;
96669   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
96670
96671   {
96672     try {
96673       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
96674     } catch (std::out_of_range& e) {
96675       {
96676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96677       };
96678     } catch (std::exception& e) {
96679       {
96680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96681       };
96682     } catch (Dali::DaliException e) {
96683       {
96684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96685       };
96686     } catch (...) {
96687       {
96688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96689       };
96690     }
96691   }
96692
96693   jresult = (void *)result;
96694   return jresult;
96695 }
96696
96697
96698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
96699   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96700
96701   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96702   {
96703     try {
96704       delete arg1;
96705     } catch (std::out_of_range& e) {
96706       {
96707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96708       };
96709     } catch (std::exception& e) {
96710       {
96711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96712       };
96713     } catch (Dali::DaliException e) {
96714       {
96715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96716       };
96717     } catch (...) {
96718       {
96719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96720       };
96721     }
96722   }
96723
96724 }
96725
96726
96727 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
96728   unsigned int jresult ;
96729   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96730   bool result;
96731
96732   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96733   {
96734     try {
96735       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
96736     } catch (std::out_of_range& e) {
96737       {
96738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96739       };
96740     } catch (std::exception& e) {
96741       {
96742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96743       };
96744     } catch (Dali::DaliException e) {
96745       {
96746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96747       };
96748     } catch (...) {
96749       {
96750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96751       };
96752     }
96753   }
96754
96755   jresult = result;
96756   return jresult;
96757 }
96758
96759
96760 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
96761   unsigned long jresult ;
96762   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96763   std::size_t result;
96764
96765   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96766   {
96767     try {
96768       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
96769     } catch (std::out_of_range& e) {
96770       {
96771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96772       };
96773     } catch (std::exception& e) {
96774       {
96775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96776       };
96777     } catch (Dali::DaliException e) {
96778       {
96779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96780       };
96781     } catch (...) {
96782       {
96783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96784       };
96785     }
96786   }
96787
96788   jresult = (unsigned long)result;
96789   return jresult;
96790 }
96791
96792
96793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
96794   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96795   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
96796
96797   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96798   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
96799   {
96800     try {
96801       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
96802     } catch (std::out_of_range& e) {
96803       {
96804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96805       };
96806     } catch (std::exception& e) {
96807       {
96808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96809       };
96810     } catch (Dali::DaliException e) {
96811       {
96812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96813       };
96814     } catch (...) {
96815       {
96816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96817       };
96818     }
96819   }
96820
96821 }
96822
96823
96824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
96825   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96826   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
96827
96828   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96829   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
96830   {
96831     try {
96832       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
96833     } catch (std::out_of_range& e) {
96834       {
96835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96836       };
96837     } catch (std::exception& e) {
96838       {
96839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96840       };
96841     } catch (Dali::DaliException e) {
96842       {
96843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96844       };
96845     } catch (...) {
96846       {
96847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96848       };
96849     }
96850   }
96851
96852 }
96853
96854
96855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
96856   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96857   Dali::Toolkit::GaussianBlurView arg2 ;
96858   Dali::Toolkit::GaussianBlurView *argp2 ;
96859
96860   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96861   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
96862   if (!argp2) {
96863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
96864     return ;
96865   }
96866   arg2 = *argp2;
96867   {
96868     try {
96869       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
96870     } catch (std::out_of_range& e) {
96871       {
96872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96873       };
96874     } catch (std::exception& e) {
96875       {
96876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96877       };
96878     } catch (Dali::DaliException e) {
96879       {
96880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96881       };
96882     } catch (...) {
96883       {
96884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96885       };
96886     }
96887   }
96888
96889 }
96890
96891
96892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
96893   void * jresult ;
96894   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
96895
96896   {
96897     try {
96898       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
96899     } catch (std::out_of_range& e) {
96900       {
96901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96902       };
96903     } catch (std::exception& e) {
96904       {
96905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96906       };
96907     } catch (Dali::DaliException e) {
96908       {
96909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96910       };
96911     } catch (...) {
96912       {
96913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96914       };
96915     }
96916   }
96917
96918   jresult = (void *)result;
96919   return jresult;
96920 }
96921
96922
96923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
96924   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96925
96926   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96927   {
96928     try {
96929       delete arg1;
96930     } catch (std::out_of_range& e) {
96931       {
96932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96933       };
96934     } catch (std::exception& e) {
96935       {
96936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96937       };
96938     } catch (Dali::DaliException e) {
96939       {
96940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96941       };
96942     } catch (...) {
96943       {
96944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96945       };
96946     }
96947   }
96948
96949 }
96950
96951
96952 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
96953   unsigned int jresult ;
96954   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96955   bool result;
96956
96957   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96958   {
96959     try {
96960       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);
96961     } catch (std::out_of_range& e) {
96962       {
96963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96964       };
96965     } catch (std::exception& e) {
96966       {
96967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96968       };
96969     } catch (Dali::DaliException e) {
96970       {
96971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96972       };
96973     } catch (...) {
96974       {
96975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96976       };
96977     }
96978   }
96979
96980   jresult = result;
96981   return jresult;
96982 }
96983
96984
96985 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
96986   unsigned long jresult ;
96987   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96988   std::size_t result;
96989
96990   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96991   {
96992     try {
96993       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);
96994     } catch (std::out_of_range& e) {
96995       {
96996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96997       };
96998     } catch (std::exception& e) {
96999       {
97000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97001       };
97002     } catch (Dali::DaliException e) {
97003       {
97004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97005       };
97006     } catch (...) {
97007       {
97008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97009       };
97010     }
97011   }
97012
97013   jresult = (unsigned long)result;
97014   return jresult;
97015 }
97016
97017
97018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
97019   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97020   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
97021
97022   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97023   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
97024   {
97025     try {
97026       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
97027     } catch (std::out_of_range& e) {
97028       {
97029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97030       };
97031     } catch (std::exception& e) {
97032       {
97033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97034       };
97035     } catch (Dali::DaliException e) {
97036       {
97037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97038       };
97039     } catch (...) {
97040       {
97041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97042       };
97043     }
97044   }
97045
97046 }
97047
97048
97049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
97050   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97051   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
97052
97053   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97054   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
97055   {
97056     try {
97057       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
97058     } catch (std::out_of_range& e) {
97059       {
97060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97061       };
97062     } catch (std::exception& e) {
97063       {
97064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97065       };
97066     } catch (Dali::DaliException e) {
97067       {
97068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97069       };
97070     } catch (...) {
97071       {
97072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97073       };
97074     }
97075   }
97076
97077 }
97078
97079
97080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
97081   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97082   Dali::Toolkit::PageTurnView arg2 ;
97083   unsigned int arg3 ;
97084   bool arg4 ;
97085   Dali::Toolkit::PageTurnView *argp2 ;
97086
97087   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97088   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
97089   if (!argp2) {
97090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
97091     return ;
97092   }
97093   arg2 = *argp2;
97094   arg3 = (unsigned int)jarg3;
97095   arg4 = jarg4 ? true : false;
97096   {
97097     try {
97098       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
97099     } catch (std::out_of_range& e) {
97100       {
97101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97102       };
97103     } catch (std::exception& e) {
97104       {
97105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97106       };
97107     } catch (Dali::DaliException e) {
97108       {
97109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97110       };
97111     } catch (...) {
97112       {
97113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97114       };
97115     }
97116   }
97117
97118 }
97119
97120
97121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
97122   void * jresult ;
97123   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
97124
97125   {
97126     try {
97127       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
97128     } catch (std::out_of_range& e) {
97129       {
97130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97131       };
97132     } catch (std::exception& e) {
97133       {
97134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97135       };
97136     } catch (Dali::DaliException e) {
97137       {
97138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97139       };
97140     } catch (...) {
97141       {
97142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97143       };
97144     }
97145   }
97146
97147   jresult = (void *)result;
97148   return jresult;
97149 }
97150
97151
97152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
97153   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97154
97155   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97156   {
97157     try {
97158       delete arg1;
97159     } catch (std::out_of_range& e) {
97160       {
97161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97162       };
97163     } catch (std::exception& e) {
97164       {
97165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97166       };
97167     } catch (Dali::DaliException e) {
97168       {
97169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97170       };
97171     } catch (...) {
97172       {
97173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97174       };
97175     }
97176   }
97177
97178 }
97179
97180
97181 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
97182   unsigned int jresult ;
97183   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97184   bool result;
97185
97186   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97187   {
97188     try {
97189       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
97190     } catch (std::out_of_range& e) {
97191       {
97192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97193       };
97194     } catch (std::exception& e) {
97195       {
97196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97197       };
97198     } catch (Dali::DaliException e) {
97199       {
97200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97201       };
97202     } catch (...) {
97203       {
97204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97205       };
97206     }
97207   }
97208
97209   jresult = result;
97210   return jresult;
97211 }
97212
97213
97214 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
97215   unsigned long jresult ;
97216   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97217   std::size_t result;
97218
97219   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97220   {
97221     try {
97222       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
97223     } catch (std::out_of_range& e) {
97224       {
97225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97226       };
97227     } catch (std::exception& e) {
97228       {
97229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97230       };
97231     } catch (Dali::DaliException e) {
97232       {
97233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97234       };
97235     } catch (...) {
97236       {
97237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97238       };
97239     }
97240   }
97241
97242   jresult = (unsigned long)result;
97243   return jresult;
97244 }
97245
97246
97247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
97248   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97249   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
97250
97251   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97252   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
97253   {
97254     try {
97255       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
97256     } catch (std::out_of_range& e) {
97257       {
97258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97259       };
97260     } catch (std::exception& e) {
97261       {
97262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97263       };
97264     } catch (Dali::DaliException e) {
97265       {
97266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97267       };
97268     } catch (...) {
97269       {
97270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97271       };
97272     }
97273   }
97274
97275 }
97276
97277
97278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
97279   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97280   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
97281
97282   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97283   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
97284   {
97285     try {
97286       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
97287     } catch (std::out_of_range& e) {
97288       {
97289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97290       };
97291     } catch (std::exception& e) {
97292       {
97293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97294       };
97295     } catch (Dali::DaliException e) {
97296       {
97297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97298       };
97299     } catch (...) {
97300       {
97301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97302       };
97303     }
97304   }
97305
97306 }
97307
97308
97309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
97310   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97311   Dali::Toolkit::PageTurnView arg2 ;
97312   Dali::Toolkit::PageTurnView *argp2 ;
97313
97314   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97315   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
97316   if (!argp2) {
97317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
97318     return ;
97319   }
97320   arg2 = *argp2;
97321   {
97322     try {
97323       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
97324     } catch (std::out_of_range& e) {
97325       {
97326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97327       };
97328     } catch (std::exception& e) {
97329       {
97330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97331       };
97332     } catch (Dali::DaliException e) {
97333       {
97334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97335       };
97336     } catch (...) {
97337       {
97338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97339       };
97340     }
97341   }
97342
97343 }
97344
97345
97346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
97347   void * jresult ;
97348   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
97349
97350   {
97351     try {
97352       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
97353     } catch (std::out_of_range& e) {
97354       {
97355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97356       };
97357     } catch (std::exception& e) {
97358       {
97359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97360       };
97361     } catch (Dali::DaliException e) {
97362       {
97363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97364       };
97365     } catch (...) {
97366       {
97367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97368       };
97369     }
97370   }
97371
97372   jresult = (void *)result;
97373   return jresult;
97374 }
97375
97376
97377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
97378   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97379
97380   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97381   {
97382     try {
97383       delete arg1;
97384     } catch (std::out_of_range& e) {
97385       {
97386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97387       };
97388     } catch (std::exception& e) {
97389       {
97390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97391       };
97392     } catch (Dali::DaliException e) {
97393       {
97394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97395       };
97396     } catch (...) {
97397       {
97398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97399       };
97400     }
97401   }
97402
97403 }
97404
97405
97406 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
97407   unsigned int jresult ;
97408   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97409   bool result;
97410
97411   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97412   {
97413     try {
97414       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);
97415     } catch (std::out_of_range& e) {
97416       {
97417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97418       };
97419     } catch (std::exception& e) {
97420       {
97421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97422       };
97423     } catch (Dali::DaliException e) {
97424       {
97425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97426       };
97427     } catch (...) {
97428       {
97429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97430       };
97431     }
97432   }
97433
97434   jresult = result;
97435   return jresult;
97436 }
97437
97438
97439 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
97440   unsigned long jresult ;
97441   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97442   std::size_t result;
97443
97444   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97445   {
97446     try {
97447       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);
97448     } catch (std::out_of_range& e) {
97449       {
97450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97451       };
97452     } catch (std::exception& e) {
97453       {
97454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97455       };
97456     } catch (Dali::DaliException e) {
97457       {
97458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97459       };
97460     } catch (...) {
97461       {
97462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97463       };
97464     }
97465   }
97466
97467   jresult = (unsigned long)result;
97468   return jresult;
97469 }
97470
97471
97472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
97473   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97474   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97475
97476   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97477   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97478   {
97479     try {
97480       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
97481     } catch (std::out_of_range& e) {
97482       {
97483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97484       };
97485     } catch (std::exception& e) {
97486       {
97487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97488       };
97489     } catch (Dali::DaliException e) {
97490       {
97491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97492       };
97493     } catch (...) {
97494       {
97495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97496       };
97497     }
97498   }
97499
97500 }
97501
97502
97503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
97504   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97505   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97506
97507   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97508   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97509   {
97510     try {
97511       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
97512     } catch (std::out_of_range& e) {
97513       {
97514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97515       };
97516     } catch (std::exception& e) {
97517       {
97518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97519       };
97520     } catch (Dali::DaliException e) {
97521       {
97522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97523       };
97524     } catch (...) {
97525       {
97526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97527       };
97528     }
97529   }
97530
97531 }
97532
97533
97534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
97535   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97536   Dali::Toolkit::ProgressBar arg2 ;
97537   float arg3 ;
97538   float arg4 ;
97539   Dali::Toolkit::ProgressBar *argp2 ;
97540
97541   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97542   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
97543   if (!argp2) {
97544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
97545     return ;
97546   }
97547   arg2 = *argp2;
97548   arg3 = (float)jarg3;
97549   arg4 = (float)jarg4;
97550   {
97551     try {
97552       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
97553     } catch (std::out_of_range& e) {
97554       {
97555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97556       };
97557     } catch (std::exception& e) {
97558       {
97559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97560       };
97561     } catch (Dali::DaliException e) {
97562       {
97563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97564       };
97565     } catch (...) {
97566       {
97567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97568       };
97569     }
97570   }
97571
97572 }
97573
97574
97575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
97576   void * jresult ;
97577   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
97578
97579   {
97580     try {
97581       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
97582     } catch (std::out_of_range& e) {
97583       {
97584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97585       };
97586     } catch (std::exception& e) {
97587       {
97588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97589       };
97590     } catch (Dali::DaliException e) {
97591       {
97592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97593       };
97594     } catch (...) {
97595       {
97596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97597       };
97598     }
97599   }
97600
97601   jresult = (void *)result;
97602   return jresult;
97603 }
97604
97605
97606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
97607   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97608
97609   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97610   {
97611     try {
97612       delete arg1;
97613     } catch (std::out_of_range& e) {
97614       {
97615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97616       };
97617     } catch (std::exception& e) {
97618       {
97619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97620       };
97621     } catch (Dali::DaliException e) {
97622       {
97623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97624       };
97625     } catch (...) {
97626       {
97627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97628       };
97629     }
97630   }
97631
97632 }
97633
97634
97635 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
97636   unsigned int jresult ;
97637   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97638   bool result;
97639
97640   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97641   {
97642     try {
97643       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);
97644     } catch (std::out_of_range& e) {
97645       {
97646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97647       };
97648     } catch (std::exception& e) {
97649       {
97650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97651       };
97652     } catch (Dali::DaliException e) {
97653       {
97654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97655       };
97656     } catch (...) {
97657       {
97658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97659       };
97660     }
97661   }
97662
97663   jresult = result;
97664   return jresult;
97665 }
97666
97667
97668 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
97669   unsigned long jresult ;
97670   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97671   std::size_t result;
97672
97673   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97674   {
97675     try {
97676       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);
97677     } catch (std::out_of_range& e) {
97678       {
97679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97680       };
97681     } catch (std::exception& e) {
97682       {
97683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97684       };
97685     } catch (Dali::DaliException e) {
97686       {
97687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97688       };
97689     } catch (...) {
97690       {
97691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97692       };
97693     }
97694   }
97695
97696   jresult = (unsigned long)result;
97697   return jresult;
97698 }
97699
97700
97701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
97702   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97703   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
97704
97705   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97706   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
97707   {
97708     try {
97709       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
97710     } catch (std::out_of_range& e) {
97711       {
97712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97713       };
97714     } catch (std::exception& e) {
97715       {
97716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97717       };
97718     } catch (Dali::DaliException e) {
97719       {
97720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97721       };
97722     } catch (...) {
97723       {
97724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97725       };
97726     }
97727   }
97728
97729 }
97730
97731
97732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
97733   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97734   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
97735
97736   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97737   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
97738   {
97739     try {
97740       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
97741     } catch (std::out_of_range& e) {
97742       {
97743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97744       };
97745     } catch (std::exception& e) {
97746       {
97747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97748       };
97749     } catch (Dali::DaliException e) {
97750       {
97751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97752       };
97753     } catch (...) {
97754       {
97755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97756       };
97757     }
97758   }
97759
97760 }
97761
97762
97763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
97764   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97765   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
97766
97767   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97768   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
97769   if (!arg2) {
97770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
97771     return ;
97772   }
97773   {
97774     try {
97775       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
97776     } catch (std::out_of_range& e) {
97777       {
97778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97779       };
97780     } catch (std::exception& e) {
97781       {
97782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97783       };
97784     } catch (Dali::DaliException e) {
97785       {
97786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97787       };
97788     } catch (...) {
97789       {
97790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97791       };
97792     }
97793   }
97794
97795 }
97796
97797
97798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
97799   void * jresult ;
97800   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
97801
97802   {
97803     try {
97804       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
97805     } catch (std::out_of_range& e) {
97806       {
97807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97808       };
97809     } catch (std::exception& e) {
97810       {
97811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97812       };
97813     } catch (Dali::DaliException e) {
97814       {
97815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97816       };
97817     } catch (...) {
97818       {
97819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97820       };
97821     }
97822   }
97823
97824   jresult = (void *)result;
97825   return jresult;
97826 }
97827
97828
97829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
97830   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97831
97832   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97833   {
97834     try {
97835       delete arg1;
97836     } catch (std::out_of_range& e) {
97837       {
97838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97839       };
97840     } catch (std::exception& e) {
97841       {
97842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97843       };
97844     } catch (Dali::DaliException e) {
97845       {
97846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97847       };
97848     } catch (...) {
97849       {
97850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97851       };
97852     }
97853   }
97854
97855 }
97856
97857
97858 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
97859   unsigned int jresult ;
97860   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97861   bool result;
97862
97863   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97864   {
97865     try {
97866       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
97867     } catch (std::out_of_range& e) {
97868       {
97869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97870       };
97871     } catch (std::exception& e) {
97872       {
97873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97874       };
97875     } catch (Dali::DaliException e) {
97876       {
97877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97878       };
97879     } catch (...) {
97880       {
97881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97882       };
97883     }
97884   }
97885
97886   jresult = result;
97887   return jresult;
97888 }
97889
97890
97891 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
97892   unsigned long jresult ;
97893   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97894   std::size_t result;
97895
97896   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97897   {
97898     try {
97899       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
97900     } catch (std::out_of_range& e) {
97901       {
97902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97903       };
97904     } catch (std::exception& e) {
97905       {
97906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97907       };
97908     } catch (Dali::DaliException e) {
97909       {
97910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97911       };
97912     } catch (...) {
97913       {
97914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97915       };
97916     }
97917   }
97918
97919   jresult = (unsigned long)result;
97920   return jresult;
97921 }
97922
97923
97924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
97925   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97926   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
97927
97928   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97929   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
97930   {
97931     try {
97932       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
97933     } catch (std::out_of_range& e) {
97934       {
97935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97936       };
97937     } catch (std::exception& e) {
97938       {
97939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97940       };
97941     } catch (Dali::DaliException e) {
97942       {
97943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97944       };
97945     } catch (...) {
97946       {
97947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97948       };
97949     }
97950   }
97951
97952 }
97953
97954
97955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
97956   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97957   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
97958
97959   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97960   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
97961   {
97962     try {
97963       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
97964     } catch (std::out_of_range& e) {
97965       {
97966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97967       };
97968     } catch (std::exception& e) {
97969       {
97970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97971       };
97972     } catch (Dali::DaliException e) {
97973       {
97974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97975       };
97976     } catch (...) {
97977       {
97978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97979       };
97980     }
97981   }
97982
97983 }
97984
97985
97986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
97987   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97988   Dali::Vector2 *arg2 = 0 ;
97989
97990   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97991   arg2 = (Dali::Vector2 *)jarg2;
97992   if (!arg2) {
97993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
97994     return ;
97995   }
97996   {
97997     try {
97998       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
97999     } catch (std::out_of_range& e) {
98000       {
98001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98002       };
98003     } catch (std::exception& e) {
98004       {
98005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98006       };
98007     } catch (Dali::DaliException e) {
98008       {
98009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98010       };
98011     } catch (...) {
98012       {
98013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98014       };
98015     }
98016   }
98017
98018 }
98019
98020
98021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
98022   void * jresult ;
98023   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
98024
98025   {
98026     try {
98027       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
98028     } catch (std::out_of_range& e) {
98029       {
98030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98031       };
98032     } catch (std::exception& e) {
98033       {
98034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98035       };
98036     } catch (Dali::DaliException e) {
98037       {
98038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98039       };
98040     } catch (...) {
98041       {
98042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98043       };
98044     }
98045   }
98046
98047   jresult = (void *)result;
98048   return jresult;
98049 }
98050
98051
98052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
98053   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98054
98055   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98056   {
98057     try {
98058       delete arg1;
98059     } catch (std::out_of_range& e) {
98060       {
98061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98062       };
98063     } catch (std::exception& e) {
98064       {
98065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98066       };
98067     } catch (Dali::DaliException e) {
98068       {
98069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98070       };
98071     } catch (...) {
98072       {
98073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98074       };
98075     }
98076   }
98077
98078 }
98079
98080
98081
98082 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
98083   unsigned int jresult ;
98084   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98085   bool result;
98086
98087   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98088   {
98089     try {
98090       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);
98091     } catch (std::out_of_range& e) {
98092       {
98093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98094       };
98095     } catch (std::exception& e) {
98096       {
98097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98098       };
98099     } catch (Dali::DaliException e) {
98100       {
98101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98102       };
98103     } catch (...) {
98104       {
98105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98106       };
98107     }
98108   }
98109
98110   jresult = result;
98111   return jresult;
98112 }
98113
98114
98115 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
98116   unsigned long jresult ;
98117   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98118   std::size_t result;
98119
98120   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98121   {
98122     try {
98123       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);
98124     } catch (std::out_of_range& e) {
98125       {
98126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98127       };
98128     } catch (std::exception& e) {
98129       {
98130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98131       };
98132     } catch (Dali::DaliException e) {
98133       {
98134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98135       };
98136     } catch (...) {
98137       {
98138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98139       };
98140     }
98141   }
98142
98143   jresult = (unsigned long)result;
98144   return jresult;
98145 }
98146
98147
98148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
98149   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98150   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
98151
98152   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98153   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
98154   {
98155     try {
98156       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
98157     } catch (std::out_of_range& e) {
98158       {
98159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98160       };
98161     } catch (std::exception& e) {
98162       {
98163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98164       };
98165     } catch (Dali::DaliException e) {
98166       {
98167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98168       };
98169     } catch (...) {
98170       {
98171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98172       };
98173     }
98174   }
98175
98176 }
98177
98178
98179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
98180   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98181   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
98182
98183   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98184   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
98185   {
98186     try {
98187       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98188     } catch (std::out_of_range& e) {
98189       {
98190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98191       };
98192     } catch (std::exception& e) {
98193       {
98194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98195       };
98196     } catch (Dali::DaliException e) {
98197       {
98198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98199       };
98200     } catch (...) {
98201       {
98202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98203       };
98204     }
98205   }
98206
98207 }
98208
98209
98210 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
98211   unsigned int jresult ;
98212   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98213   Dali::Toolkit::Control arg2 ;
98214   Dali::KeyEvent *arg3 = 0 ;
98215   Dali::Toolkit::Control *argp2 ;
98216   bool result;
98217
98218   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98219   argp2 = (Dali::Toolkit::Control *)jarg2;
98220   if (!argp2) {
98221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98222     return 0;
98223   }
98224   arg2 = *argp2;
98225   arg3 = (Dali::KeyEvent *)jarg3;
98226   if (!arg3) {
98227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
98228     return 0;
98229   }
98230   {
98231     try {
98232       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);
98233     } catch (std::out_of_range& e) {
98234       {
98235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98236       };
98237     } catch (std::exception& e) {
98238       {
98239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98240       };
98241     } catch (Dali::DaliException e) {
98242       {
98243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98244       };
98245     } catch (...) {
98246       {
98247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98248       };
98249     }
98250   }
98251
98252   jresult = result;
98253   return jresult;
98254 }
98255
98256
98257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
98258   void * jresult ;
98259   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
98260
98261   {
98262     try {
98263       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
98264     } catch (std::out_of_range& e) {
98265       {
98266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98267       };
98268     } catch (std::exception& e) {
98269       {
98270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98271       };
98272     } catch (Dali::DaliException e) {
98273       {
98274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98275       };
98276     } catch (...) {
98277       {
98278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98279       };
98280     }
98281   }
98282
98283   jresult = (void *)result;
98284   return jresult;
98285 }
98286
98287
98288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
98289   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98290
98291   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98292   {
98293     try {
98294       delete arg1;
98295     } catch (std::out_of_range& e) {
98296       {
98297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98298       };
98299     } catch (std::exception& e) {
98300       {
98301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98302       };
98303     } catch (Dali::DaliException e) {
98304       {
98305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98306       };
98307     } catch (...) {
98308       {
98309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98310       };
98311     }
98312   }
98313
98314 }
98315
98316
98317 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
98318   unsigned int jresult ;
98319   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98320   bool result;
98321
98322   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98323   {
98324     try {
98325       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98326     } catch (std::out_of_range& e) {
98327       {
98328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98329       };
98330     } catch (std::exception& e) {
98331       {
98332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98333       };
98334     } catch (Dali::DaliException e) {
98335       {
98336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98337       };
98338     } catch (...) {
98339       {
98340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98341       };
98342     }
98343   }
98344
98345   jresult = result;
98346   return jresult;
98347 }
98348
98349
98350 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
98351   unsigned long jresult ;
98352   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98353   std::size_t result;
98354
98355   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98356   {
98357     try {
98358       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98359     } catch (std::out_of_range& e) {
98360       {
98361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98362       };
98363     } catch (std::exception& e) {
98364       {
98365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98366       };
98367     } catch (Dali::DaliException e) {
98368       {
98369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98370       };
98371     } catch (...) {
98372       {
98373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98374       };
98375     }
98376   }
98377
98378   jresult = (unsigned long)result;
98379   return jresult;
98380 }
98381
98382
98383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
98384   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98385   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98386
98387   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98388   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98389   {
98390     try {
98391       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
98392     } catch (std::out_of_range& e) {
98393       {
98394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98395       };
98396     } catch (std::exception& e) {
98397       {
98398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98399       };
98400     } catch (Dali::DaliException e) {
98401       {
98402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98403       };
98404     } catch (...) {
98405       {
98406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98407       };
98408     }
98409   }
98410
98411 }
98412
98413
98414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
98415   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98416   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98417
98418   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98419   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98420   {
98421     try {
98422       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
98423     } catch (std::out_of_range& e) {
98424       {
98425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98426       };
98427     } catch (std::exception& e) {
98428       {
98429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98430       };
98431     } catch (Dali::DaliException e) {
98432       {
98433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98434       };
98435     } catch (...) {
98436       {
98437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98438       };
98439     }
98440   }
98441
98442 }
98443
98444
98445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
98446   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98447   Dali::Toolkit::Control arg2 ;
98448   Dali::Toolkit::Control *argp2 ;
98449
98450   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98451   argp2 = (Dali::Toolkit::Control *)jarg2;
98452   if (!argp2) {
98453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98454     return ;
98455   }
98456   arg2 = *argp2;
98457   {
98458     try {
98459       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
98460     } catch (std::out_of_range& e) {
98461       {
98462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98463       };
98464     } catch (std::exception& e) {
98465       {
98466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98467       };
98468     } catch (Dali::DaliException e) {
98469       {
98470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98471       };
98472     } catch (...) {
98473       {
98474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98475       };
98476     }
98477   }
98478
98479 }
98480
98481
98482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
98483   void * jresult ;
98484   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
98485
98486   {
98487     try {
98488       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
98489     } catch (std::out_of_range& e) {
98490       {
98491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98492       };
98493     } catch (std::exception& e) {
98494       {
98495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98496       };
98497     } catch (Dali::DaliException e) {
98498       {
98499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98500       };
98501     } catch (...) {
98502       {
98503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98504       };
98505     }
98506   }
98507
98508   jresult = (void *)result;
98509   return jresult;
98510 }
98511
98512
98513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
98514   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98515
98516   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98517   {
98518     try {
98519       delete arg1;
98520     } catch (std::out_of_range& e) {
98521       {
98522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98523       };
98524     } catch (std::exception& e) {
98525       {
98526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98527       };
98528     } catch (Dali::DaliException e) {
98529       {
98530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98531       };
98532     } catch (...) {
98533       {
98534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98535       };
98536     }
98537   }
98538
98539 }
98540
98541
98542 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
98543   unsigned int jresult ;
98544   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98545   bool result;
98546
98547   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98548   {
98549     try {
98550       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98551     } catch (std::out_of_range& e) {
98552       {
98553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98554       };
98555     } catch (std::exception& e) {
98556       {
98557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98558       };
98559     } catch (Dali::DaliException e) {
98560       {
98561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98562       };
98563     } catch (...) {
98564       {
98565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98566       };
98567     }
98568   }
98569
98570   jresult = result;
98571   return jresult;
98572 }
98573
98574
98575 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
98576   unsigned long jresult ;
98577   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98578   std::size_t result;
98579
98580   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98581   {
98582     try {
98583       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98584     } catch (std::out_of_range& e) {
98585       {
98586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98587       };
98588     } catch (std::exception& e) {
98589       {
98590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98591       };
98592     } catch (Dali::DaliException e) {
98593       {
98594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98595       };
98596     } catch (...) {
98597       {
98598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98599       };
98600     }
98601   }
98602
98603   jresult = (unsigned long)result;
98604   return jresult;
98605 }
98606
98607
98608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
98609   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98610   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
98611
98612   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98613   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
98614   {
98615     try {
98616       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
98617     } catch (std::out_of_range& e) {
98618       {
98619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98620       };
98621     } catch (std::exception& e) {
98622       {
98623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98624       };
98625     } catch (Dali::DaliException e) {
98626       {
98627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98628       };
98629     } catch (...) {
98630       {
98631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98632       };
98633     }
98634   }
98635
98636 }
98637
98638
98639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
98640   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98641   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
98642
98643   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98644   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
98645   {
98646     try {
98647       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
98648     } catch (std::out_of_range& e) {
98649       {
98650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98651       };
98652     } catch (std::exception& e) {
98653       {
98654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98655       };
98656     } catch (Dali::DaliException e) {
98657       {
98658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98659       };
98660     } catch (...) {
98661       {
98662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98663       };
98664     }
98665   }
98666
98667 }
98668
98669
98670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
98671   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98672   Dali::Toolkit::VideoView *arg2 = 0 ;
98673
98674   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98675   arg2 = (Dali::Toolkit::VideoView *)jarg2;
98676   if (!arg2) {
98677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
98678     return ;
98679   }
98680   {
98681     try {
98682       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
98683     } catch (std::out_of_range& e) {
98684       {
98685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98686       };
98687     } catch (std::exception& e) {
98688       {
98689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98690       };
98691     } catch (Dali::DaliException e) {
98692       {
98693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98694       };
98695     } catch (...) {
98696       {
98697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98698       };
98699     }
98700   }
98701
98702 }
98703
98704
98705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
98706   void * jresult ;
98707   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
98708
98709   {
98710     try {
98711       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
98712     } catch (std::out_of_range& e) {
98713       {
98714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98715       };
98716     } catch (std::exception& e) {
98717       {
98718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98719       };
98720     } catch (Dali::DaliException e) {
98721       {
98722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98723       };
98724     } catch (...) {
98725       {
98726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98727       };
98728     }
98729   }
98730
98731   jresult = (void *)result;
98732   return jresult;
98733 }
98734
98735
98736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
98737   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98738
98739   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98740   {
98741     try {
98742       delete arg1;
98743     } catch (std::out_of_range& e) {
98744       {
98745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98746       };
98747     } catch (std::exception& e) {
98748       {
98749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98750       };
98751     } catch (Dali::DaliException e) {
98752       {
98753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98754       };
98755     } catch (...) {
98756       {
98757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98758       };
98759     }
98760   }
98761
98762 }
98763
98764
98765 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
98766   unsigned int jresult ;
98767   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98768   bool result;
98769
98770   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98771   {
98772     try {
98773       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
98774     } catch (std::out_of_range& e) {
98775       {
98776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98777       };
98778     } catch (std::exception& e) {
98779       {
98780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98781       };
98782     } catch (Dali::DaliException e) {
98783       {
98784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98785       };
98786     } catch (...) {
98787       {
98788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98789       };
98790     }
98791   }
98792
98793   jresult = result;
98794   return jresult;
98795 }
98796
98797
98798 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
98799   unsigned long jresult ;
98800   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98801   std::size_t result;
98802
98803   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98804   {
98805     try {
98806       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
98807     } catch (std::out_of_range& e) {
98808       {
98809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98810       };
98811     } catch (std::exception& e) {
98812       {
98813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98814       };
98815     } catch (Dali::DaliException e) {
98816       {
98817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98818       };
98819     } catch (...) {
98820       {
98821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98822       };
98823     }
98824   }
98825
98826   jresult = (unsigned long)result;
98827   return jresult;
98828 }
98829
98830
98831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
98832   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98833   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
98834
98835   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98836   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
98837   {
98838     try {
98839       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
98840     } catch (std::out_of_range& e) {
98841       {
98842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98843       };
98844     } catch (std::exception& e) {
98845       {
98846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98847       };
98848     } catch (Dali::DaliException e) {
98849       {
98850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98851       };
98852     } catch (...) {
98853       {
98854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98855       };
98856     }
98857   }
98858
98859 }
98860
98861
98862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
98863   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98864   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
98865
98866   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98867   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
98868   {
98869     try {
98870       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
98871     } catch (std::out_of_range& e) {
98872       {
98873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98874       };
98875     } catch (std::exception& e) {
98876       {
98877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98878       };
98879     } catch (Dali::DaliException e) {
98880       {
98881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98882       };
98883     } catch (...) {
98884       {
98885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98886       };
98887     }
98888   }
98889
98890 }
98891
98892
98893 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
98894   unsigned int jresult ;
98895   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98896   Dali::Toolkit::Slider arg2 ;
98897   float arg3 ;
98898   Dali::Toolkit::Slider *argp2 ;
98899   bool result;
98900
98901   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98902   argp2 = (Dali::Toolkit::Slider *)jarg2;
98903   if (!argp2) {
98904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
98905     return 0;
98906   }
98907   arg2 = *argp2;
98908   arg3 = (float)jarg3;
98909   {
98910     try {
98911       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
98912     } catch (std::out_of_range& e) {
98913       {
98914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98915       };
98916     } catch (std::exception& e) {
98917       {
98918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98919       };
98920     } catch (Dali::DaliException e) {
98921       {
98922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98923       };
98924     } catch (...) {
98925       {
98926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98927       };
98928     }
98929   }
98930
98931   jresult = result;
98932   return jresult;
98933 }
98934
98935
98936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
98937   void * jresult ;
98938   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
98939
98940   {
98941     try {
98942       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
98943     } catch (std::out_of_range& e) {
98944       {
98945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98946       };
98947     } catch (std::exception& e) {
98948       {
98949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98950       };
98951     } catch (Dali::DaliException e) {
98952       {
98953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98954       };
98955     } catch (...) {
98956       {
98957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98958       };
98959     }
98960   }
98961
98962   jresult = (void *)result;
98963   return jresult;
98964 }
98965
98966
98967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
98968   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98969
98970   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98971   {
98972     try {
98973       delete arg1;
98974     } catch (std::out_of_range& e) {
98975       {
98976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98977       };
98978     } catch (std::exception& e) {
98979       {
98980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98981       };
98982     } catch (Dali::DaliException e) {
98983       {
98984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98985       };
98986     } catch (...) {
98987       {
98988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98989       };
98990     }
98991   }
98992
98993 }
98994
98995
98996 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
98997   unsigned int jresult ;
98998   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98999   bool result;
99000
99001   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99002   {
99003     try {
99004       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
99005     } catch (std::out_of_range& e) {
99006       {
99007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99008       };
99009     } catch (std::exception& e) {
99010       {
99011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99012       };
99013     } catch (Dali::DaliException e) {
99014       {
99015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99016       };
99017     } catch (...) {
99018       {
99019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99020       };
99021     }
99022   }
99023
99024   jresult = result;
99025   return jresult;
99026 }
99027
99028
99029 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
99030   unsigned long jresult ;
99031   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99032   std::size_t result;
99033
99034   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99035   {
99036     try {
99037       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
99038     } catch (std::out_of_range& e) {
99039       {
99040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99041       };
99042     } catch (std::exception& e) {
99043       {
99044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99045       };
99046     } catch (Dali::DaliException e) {
99047       {
99048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99049       };
99050     } catch (...) {
99051       {
99052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99053       };
99054     }
99055   }
99056
99057   jresult = (unsigned long)result;
99058   return jresult;
99059 }
99060
99061
99062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
99063   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99064   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
99065
99066   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99067   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
99068   {
99069     try {
99070       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
99071     } catch (std::out_of_range& e) {
99072       {
99073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99074       };
99075     } catch (std::exception& e) {
99076       {
99077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99078       };
99079     } catch (Dali::DaliException e) {
99080       {
99081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99082       };
99083     } catch (...) {
99084       {
99085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99086       };
99087     }
99088   }
99089
99090 }
99091
99092
99093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
99094   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99095   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
99096
99097   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99098   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
99099   {
99100     try {
99101       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
99102     } catch (std::out_of_range& e) {
99103       {
99104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99105       };
99106     } catch (std::exception& e) {
99107       {
99108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99109       };
99110     } catch (Dali::DaliException e) {
99111       {
99112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99113       };
99114     } catch (...) {
99115       {
99116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99117       };
99118     }
99119   }
99120
99121 }
99122
99123
99124 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
99125   unsigned int jresult ;
99126   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99127   Dali::Toolkit::Slider arg2 ;
99128   int arg3 ;
99129   Dali::Toolkit::Slider *argp2 ;
99130   bool result;
99131
99132   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99133   argp2 = (Dali::Toolkit::Slider *)jarg2;
99134   if (!argp2) {
99135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
99136     return 0;
99137   }
99138   arg2 = *argp2;
99139   arg3 = (int)jarg3;
99140   {
99141     try {
99142       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
99143     } catch (std::out_of_range& e) {
99144       {
99145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99146       };
99147     } catch (std::exception& e) {
99148       {
99149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99150       };
99151     } catch (Dali::DaliException e) {
99152       {
99153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99154       };
99155     } catch (...) {
99156       {
99157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99158       };
99159     }
99160   }
99161
99162   jresult = result;
99163   return jresult;
99164 }
99165
99166
99167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
99168   void * jresult ;
99169   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
99170
99171   {
99172     try {
99173       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
99174     } catch (std::out_of_range& e) {
99175       {
99176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99177       };
99178     } catch (std::exception& e) {
99179       {
99180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99181       };
99182     } catch (Dali::DaliException e) {
99183       {
99184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99185       };
99186     } catch (...) {
99187       {
99188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99189       };
99190     }
99191   }
99192
99193   jresult = (void *)result;
99194   return jresult;
99195 }
99196
99197
99198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
99199   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99200
99201   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99202   {
99203     try {
99204       delete arg1;
99205     } catch (std::out_of_range& e) {
99206       {
99207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99208       };
99209     } catch (std::exception& e) {
99210       {
99211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99212       };
99213     } catch (Dali::DaliException e) {
99214       {
99215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99216       };
99217     } catch (...) {
99218       {
99219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99220       };
99221     }
99222   }
99223
99224 }
99225
99226
99227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
99228   void * jresult ;
99229   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99230
99231   {
99232     try {
99233       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
99234     } catch (std::out_of_range& e) {
99235       {
99236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99237       };
99238     } catch (std::exception& e) {
99239       {
99240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99241       };
99242     } catch (Dali::DaliException e) {
99243       {
99244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99245       };
99246     } catch (...) {
99247       {
99248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99249       };
99250     }
99251   }
99252
99253   jresult = (void *)result;
99254   return jresult;
99255 }
99256
99257
99258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
99259   void * jresult ;
99260   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
99261   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99262
99263   arg1 = (Dali::Toolkit::Ruler *)jarg1;
99264   {
99265     try {
99266       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
99267     } catch (std::out_of_range& e) {
99268       {
99269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99270       };
99271     } catch (std::exception& e) {
99272       {
99273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99274       };
99275     } catch (Dali::DaliException e) {
99276       {
99277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99278       };
99279     } catch (...) {
99280       {
99281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99282       };
99283     }
99284   }
99285
99286   jresult = (void *)result;
99287   return jresult;
99288 }
99289
99290
99291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
99292   void * jresult ;
99293   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
99294   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99295
99296   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99297   if (!arg1) {
99298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99299     return 0;
99300   }
99301   {
99302     try {
99303       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
99304     } catch (std::out_of_range& e) {
99305       {
99306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99307       };
99308     } catch (std::exception& e) {
99309       {
99310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99311       };
99312     } catch (Dali::DaliException e) {
99313       {
99314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99315       };
99316     } catch (...) {
99317       {
99318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99319       };
99320     }
99321   }
99322
99323   jresult = (void *)result;
99324   return jresult;
99325 }
99326
99327
99328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
99329   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99330
99331   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99332   {
99333     try {
99334       delete arg1;
99335     } catch (std::out_of_range& e) {
99336       {
99337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99338       };
99339     } catch (std::exception& e) {
99340       {
99341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99342       };
99343     } catch (Dali::DaliException e) {
99344       {
99345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99346       };
99347     } catch (...) {
99348       {
99349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99350       };
99351     }
99352   }
99353
99354 }
99355
99356
99357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
99358   void * jresult ;
99359   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99360   Dali::Toolkit::Ruler *result = 0 ;
99361
99362   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99363   {
99364     try {
99365       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
99366     } catch (std::out_of_range& e) {
99367       {
99368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99369       };
99370     } catch (std::exception& e) {
99371       {
99372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99373       };
99374     } catch (Dali::DaliException e) {
99375       {
99376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99377       };
99378     } catch (...) {
99379       {
99380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99381       };
99382     }
99383   }
99384
99385   jresult = (void *)result;
99386   return jresult;
99387 }
99388
99389
99390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
99391   void * jresult ;
99392   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99393   Dali::Toolkit::Ruler *result = 0 ;
99394
99395   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99396   {
99397     try {
99398       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
99399     } catch (std::out_of_range& e) {
99400       {
99401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99402       };
99403     } catch (std::exception& e) {
99404       {
99405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99406       };
99407     } catch (Dali::DaliException e) {
99408       {
99409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99410       };
99411     } catch (...) {
99412       {
99413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99414       };
99415     }
99416   }
99417
99418   jresult = (void *)result;
99419   return jresult;
99420 }
99421
99422
99423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
99424   void * jresult ;
99425   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99426   Dali::Toolkit::Ruler *result = 0 ;
99427
99428   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99429   {
99430     try {
99431       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
99432     } catch (std::out_of_range& e) {
99433       {
99434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99435       };
99436     } catch (std::exception& e) {
99437       {
99438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99439       };
99440     } catch (Dali::DaliException e) {
99441       {
99442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99443       };
99444     } catch (...) {
99445       {
99446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99447       };
99448     }
99449   }
99450
99451   jresult = (void *)result;
99452   return jresult;
99453 }
99454
99455
99456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
99457   void * jresult ;
99458   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99459   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
99460   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99461
99462   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99463   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
99464   if (!arg2) {
99465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99466     return 0;
99467   }
99468   {
99469     try {
99470       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
99471     } catch (std::out_of_range& e) {
99472       {
99473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99474       };
99475     } catch (std::exception& e) {
99476       {
99477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99478       };
99479     } catch (Dali::DaliException e) {
99480       {
99481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99482       };
99483     } catch (...) {
99484       {
99485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99486       };
99487     }
99488   }
99489
99490   jresult = (void *)result;
99491   return jresult;
99492 }
99493
99494
99495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
99496   void * jresult ;
99497   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99498   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99499   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99500
99501   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99502   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99503   {
99504     try {
99505       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
99506     } catch (std::out_of_range& e) {
99507       {
99508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99509       };
99510     } catch (std::exception& e) {
99511       {
99512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99513       };
99514     } catch (Dali::DaliException e) {
99515       {
99516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99517       };
99518     } catch (...) {
99519       {
99520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99521       };
99522     }
99523   }
99524
99525   jresult = (void *)result;
99526   return jresult;
99527 }
99528
99529
99530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
99531   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99532
99533   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99534   {
99535     try {
99536       (arg1)->Reset();
99537     } catch (std::out_of_range& e) {
99538       {
99539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99540       };
99541     } catch (std::exception& e) {
99542       {
99543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99544       };
99545     } catch (Dali::DaliException e) {
99546       {
99547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99548       };
99549     } catch (...) {
99550       {
99551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99552       };
99553     }
99554   }
99555
99556 }
99557
99558
99559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
99560   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99561   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99562
99563   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99564   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99565   {
99566     try {
99567       (arg1)->Reset(arg2);
99568     } catch (std::out_of_range& e) {
99569       {
99570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99571       };
99572     } catch (std::exception& e) {
99573       {
99574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99575       };
99576     } catch (Dali::DaliException e) {
99577       {
99578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99579       };
99580     } catch (...) {
99581       {
99582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99583       };
99584     }
99585   }
99586
99587 }
99588
99589
99590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
99591   void * jresult ;
99592   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99593   Dali::Toolkit::Ruler *result = 0 ;
99594
99595   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99596   {
99597     try {
99598       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
99599     } catch (std::out_of_range& e) {
99600       {
99601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99602       };
99603     } catch (std::exception& e) {
99604       {
99605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99606       };
99607     } catch (Dali::DaliException e) {
99608       {
99609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99610       };
99611     } catch (...) {
99612       {
99613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99614       };
99615     }
99616   }
99617
99618   jresult = (void *)result;
99619   return jresult;
99620 }
99621
99622
99623 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
99624   float jresult ;
99625   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99626   float arg2 ;
99627   float arg3 ;
99628   float result;
99629
99630   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99631   arg2 = (float)jarg2;
99632   arg3 = (float)jarg3;
99633   {
99634     try {
99635       result = (float)(*arg1)->Snap(arg2,arg3);
99636     } catch (std::out_of_range& e) {
99637       {
99638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99639       };
99640     } catch (std::exception& e) {
99641       {
99642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99643       };
99644     } catch (Dali::DaliException e) {
99645       {
99646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99647       };
99648     } catch (...) {
99649       {
99650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99651       };
99652     }
99653   }
99654
99655   jresult = result;
99656   return jresult;
99657 }
99658
99659
99660 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
99661   float jresult ;
99662   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99663   float arg2 ;
99664   float result;
99665
99666   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99667   arg2 = (float)jarg2;
99668   {
99669     try {
99670       result = (float)(*arg1)->Snap(arg2);
99671     } catch (std::out_of_range& e) {
99672       {
99673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99674       };
99675     } catch (std::exception& e) {
99676       {
99677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99678       };
99679     } catch (Dali::DaliException e) {
99680       {
99681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99682       };
99683     } catch (...) {
99684       {
99685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99686       };
99687     }
99688   }
99689
99690   jresult = result;
99691   return jresult;
99692 }
99693
99694
99695 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
99696   float jresult ;
99697   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99698   unsigned int arg2 ;
99699   unsigned int *arg3 = 0 ;
99700   bool arg4 ;
99701   float result;
99702
99703   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99704   arg2 = (unsigned int)jarg2;
99705   arg3 = (unsigned int *)jarg3;
99706   arg4 = jarg4 ? true : false;
99707   {
99708     try {
99709       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
99710     } catch (std::out_of_range& e) {
99711       {
99712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99713       };
99714     } catch (std::exception& e) {
99715       {
99716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99717       };
99718     } catch (Dali::DaliException e) {
99719       {
99720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99721       };
99722     } catch (...) {
99723       {
99724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99725       };
99726     }
99727   }
99728
99729   jresult = result;
99730   return jresult;
99731 }
99732
99733
99734 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
99735   unsigned int jresult ;
99736   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99737   float arg2 ;
99738   bool arg3 ;
99739   unsigned int result;
99740
99741   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99742   arg2 = (float)jarg2;
99743   arg3 = jarg3 ? true : false;
99744   {
99745     try {
99746       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
99747     } catch (std::out_of_range& e) {
99748       {
99749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99750       };
99751     } catch (std::exception& e) {
99752       {
99753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99754       };
99755     } catch (Dali::DaliException e) {
99756       {
99757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99758       };
99759     } catch (...) {
99760       {
99761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99762       };
99763     }
99764   }
99765
99766   jresult = result;
99767   return jresult;
99768 }
99769
99770
99771 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
99772   unsigned int jresult ;
99773   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99774   unsigned int result;
99775
99776   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99777   {
99778     try {
99779       result = (unsigned int)(*arg1)->GetTotalPages();
99780     } catch (std::out_of_range& e) {
99781       {
99782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99783       };
99784     } catch (std::exception& e) {
99785       {
99786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99787       };
99788     } catch (Dali::DaliException e) {
99789       {
99790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99791       };
99792     } catch (...) {
99793       {
99794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99795       };
99796     }
99797   }
99798
99799   jresult = result;
99800   return jresult;
99801 }
99802
99803
99804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
99805   int jresult ;
99806   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99807   Dali::Toolkit::Ruler::RulerType result;
99808
99809   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99810   {
99811     try {
99812       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
99813     } catch (std::out_of_range& e) {
99814       {
99815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99816       };
99817     } catch (std::exception& e) {
99818       {
99819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99820       };
99821     } catch (Dali::DaliException e) {
99822       {
99823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99824       };
99825     } catch (...) {
99826       {
99827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99828       };
99829     }
99830   }
99831
99832   jresult = (int)result;
99833   return jresult;
99834 }
99835
99836
99837 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
99838   unsigned int jresult ;
99839   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99840   bool result;
99841
99842   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99843   {
99844     try {
99845       result = (bool)(*arg1)->IsEnabled();
99846     } catch (std::out_of_range& e) {
99847       {
99848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99849       };
99850     } catch (std::exception& e) {
99851       {
99852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99853       };
99854     } catch (Dali::DaliException e) {
99855       {
99856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99857       };
99858     } catch (...) {
99859       {
99860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99861       };
99862     }
99863   }
99864
99865   jresult = result;
99866   return jresult;
99867 }
99868
99869
99870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
99871   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99872
99873   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99874   {
99875     try {
99876       (*arg1)->Enable();
99877     } catch (std::out_of_range& e) {
99878       {
99879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99880       };
99881     } catch (std::exception& e) {
99882       {
99883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99884       };
99885     } catch (Dali::DaliException e) {
99886       {
99887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99888       };
99889     } catch (...) {
99890       {
99891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99892       };
99893     }
99894   }
99895
99896 }
99897
99898
99899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
99900   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99901
99902   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99903   {
99904     try {
99905       (*arg1)->Disable();
99906     } catch (std::out_of_range& e) {
99907       {
99908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99909       };
99910     } catch (std::exception& e) {
99911       {
99912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99913       };
99914     } catch (Dali::DaliException e) {
99915       {
99916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99917       };
99918     } catch (...) {
99919       {
99920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99921       };
99922     }
99923   }
99924
99925 }
99926
99927
99928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
99929   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99930   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
99931   Dali::Toolkit::RulerDomain *argp2 ;
99932
99933   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99934   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
99935   if (!argp2) {
99936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
99937     return ;
99938   }
99939   arg2 = *argp2;
99940   {
99941     try {
99942       (*arg1)->SetDomain(arg2);
99943     } catch (std::out_of_range& e) {
99944       {
99945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99946       };
99947     } catch (std::exception& e) {
99948       {
99949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99950       };
99951     } catch (Dali::DaliException e) {
99952       {
99953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99954       };
99955     } catch (...) {
99956       {
99957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99958       };
99959     }
99960   }
99961
99962 }
99963
99964
99965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
99966   void * jresult ;
99967   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99968   Dali::Toolkit::RulerDomain *result = 0 ;
99969
99970   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99971   {
99972     try {
99973       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
99974     } catch (std::out_of_range& e) {
99975       {
99976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99977       };
99978     } catch (std::exception& e) {
99979       {
99980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99981       };
99982     } catch (Dali::DaliException e) {
99983       {
99984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99985       };
99986     } catch (...) {
99987       {
99988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99989       };
99990     }
99991   }
99992
99993   jresult = (void *)result;
99994   return jresult;
99995 }
99996
99997
99998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
99999   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100000
100001   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100002   {
100003     try {
100004       (*arg1)->DisableDomain();
100005     } catch (std::out_of_range& e) {
100006       {
100007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100008       };
100009     } catch (std::exception& e) {
100010       {
100011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100012       };
100013     } catch (Dali::DaliException e) {
100014       {
100015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100016       };
100017     } catch (...) {
100018       {
100019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100020       };
100021     }
100022   }
100023
100024 }
100025
100026
100027 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
100028   float jresult ;
100029   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100030   float arg2 ;
100031   float arg3 ;
100032   float arg4 ;
100033   float result;
100034
100035   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100036   arg2 = (float)jarg2;
100037   arg3 = (float)jarg3;
100038   arg4 = (float)jarg4;
100039   {
100040     try {
100041       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
100042     } catch (std::out_of_range& e) {
100043       {
100044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100045       };
100046     } catch (std::exception& e) {
100047       {
100048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100049       };
100050     } catch (Dali::DaliException e) {
100051       {
100052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100053       };
100054     } catch (...) {
100055       {
100056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100057       };
100058     }
100059   }
100060
100061   jresult = result;
100062   return jresult;
100063 }
100064
100065
100066 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
100067   float jresult ;
100068   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100069   float arg2 ;
100070   float arg3 ;
100071   float result;
100072
100073   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100074   arg2 = (float)jarg2;
100075   arg3 = (float)jarg3;
100076   {
100077     try {
100078       result = (float)(*arg1)->Clamp(arg2,arg3);
100079     } catch (std::out_of_range& e) {
100080       {
100081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100082       };
100083     } catch (std::exception& e) {
100084       {
100085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100086       };
100087     } catch (Dali::DaliException e) {
100088       {
100089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100090       };
100091     } catch (...) {
100092       {
100093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100094       };
100095     }
100096   }
100097
100098   jresult = result;
100099   return jresult;
100100 }
100101
100102
100103 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
100104   float jresult ;
100105   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100106   float arg2 ;
100107   float result;
100108
100109   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100110   arg2 = (float)jarg2;
100111   {
100112     try {
100113       result = (float)(*arg1)->Clamp(arg2);
100114     } catch (std::out_of_range& e) {
100115       {
100116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100117       };
100118     } catch (std::exception& e) {
100119       {
100120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100121       };
100122     } catch (Dali::DaliException e) {
100123       {
100124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100125       };
100126     } catch (...) {
100127       {
100128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100129       };
100130     }
100131   }
100132
100133   jresult = result;
100134   return jresult;
100135 }
100136
100137
100138 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
100139   float jresult ;
100140   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100141   float arg2 ;
100142   float arg3 ;
100143   float arg4 ;
100144   Dali::Toolkit::ClampState *arg5 = 0 ;
100145   float result;
100146
100147   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100148   arg2 = (float)jarg2;
100149   arg3 = (float)jarg3;
100150   arg4 = (float)jarg4;
100151   arg5 = (Dali::Toolkit::ClampState *)jarg5;
100152   if (!arg5) {
100153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100154     return 0;
100155   }
100156   {
100157     try {
100158       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
100159     } catch (std::out_of_range& e) {
100160       {
100161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100162       };
100163     } catch (std::exception& e) {
100164       {
100165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100166       };
100167     } catch (Dali::DaliException e) {
100168       {
100169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100170       };
100171     } catch (...) {
100172       {
100173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100174       };
100175     }
100176   }
100177
100178   jresult = result;
100179   return jresult;
100180 }
100181
100182
100183 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
100184   float jresult ;
100185   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100186   float arg2 ;
100187   float arg3 ;
100188   float arg4 ;
100189   float arg5 ;
100190   float result;
100191
100192   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100193   arg2 = (float)jarg2;
100194   arg3 = (float)jarg3;
100195   arg4 = (float)jarg4;
100196   arg5 = (float)jarg5;
100197   {
100198     try {
100199       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
100200     } catch (std::out_of_range& e) {
100201       {
100202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100203       };
100204     } catch (std::exception& e) {
100205       {
100206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100207       };
100208     } catch (Dali::DaliException e) {
100209       {
100210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100211       };
100212     } catch (...) {
100213       {
100214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100215       };
100216     }
100217   }
100218
100219   jresult = result;
100220   return jresult;
100221 }
100222
100223
100224 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
100225   float jresult ;
100226   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100227   float arg2 ;
100228   float arg3 ;
100229   float arg4 ;
100230   float result;
100231
100232   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100233   arg2 = (float)jarg2;
100234   arg3 = (float)jarg3;
100235   arg4 = (float)jarg4;
100236   {
100237     try {
100238       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
100239     } catch (std::out_of_range& e) {
100240       {
100241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100242       };
100243     } catch (std::exception& e) {
100244       {
100245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100246       };
100247     } catch (Dali::DaliException e) {
100248       {
100249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100250       };
100251     } catch (...) {
100252       {
100253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100254       };
100255     }
100256   }
100257
100258   jresult = result;
100259   return jresult;
100260 }
100261
100262
100263 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
100264   float jresult ;
100265   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100266   float arg2 ;
100267   float arg3 ;
100268   float result;
100269
100270   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100271   arg2 = (float)jarg2;
100272   arg3 = (float)jarg3;
100273   {
100274     try {
100275       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
100276     } catch (std::out_of_range& e) {
100277       {
100278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100279       };
100280     } catch (std::exception& e) {
100281       {
100282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100283       };
100284     } catch (Dali::DaliException e) {
100285       {
100286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100287       };
100288     } catch (...) {
100289       {
100290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100291       };
100292     }
100293   }
100294
100295   jresult = result;
100296   return jresult;
100297 }
100298
100299
100300 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
100301   float jresult ;
100302   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100303   float arg2 ;
100304   float result;
100305
100306   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100307   arg2 = (float)jarg2;
100308   {
100309     try {
100310       result = (float)(*arg1)->SnapAndClamp(arg2);
100311     } catch (std::out_of_range& e) {
100312       {
100313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100314       };
100315     } catch (std::exception& e) {
100316       {
100317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100318       };
100319     } catch (Dali::DaliException e) {
100320       {
100321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100322       };
100323     } catch (...) {
100324       {
100325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100326       };
100327     }
100328   }
100329
100330   jresult = result;
100331   return jresult;
100332 }
100333
100334
100335 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
100336   float jresult ;
100337   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100338   float arg2 ;
100339   float arg3 ;
100340   float arg4 ;
100341   float arg5 ;
100342   Dali::Toolkit::ClampState *arg6 = 0 ;
100343   float result;
100344
100345   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100346   arg2 = (float)jarg2;
100347   arg3 = (float)jarg3;
100348   arg4 = (float)jarg4;
100349   arg5 = (float)jarg5;
100350   arg6 = (Dali::Toolkit::ClampState *)jarg6;
100351   if (!arg6) {
100352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100353     return 0;
100354   }
100355   {
100356     try {
100357       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
100358     } catch (std::out_of_range& e) {
100359       {
100360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100361       };
100362     } catch (std::exception& e) {
100363       {
100364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100365       };
100366     } catch (Dali::DaliException e) {
100367       {
100368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100369       };
100370     } catch (...) {
100371       {
100372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100373       };
100374     }
100375   }
100376
100377   jresult = result;
100378   return jresult;
100379 }
100380
100381
100382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
100383   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100384
100385   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100386   {
100387     try {
100388       (*arg1)->Reference();
100389     } catch (std::out_of_range& e) {
100390       {
100391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100392       };
100393     } catch (std::exception& e) {
100394       {
100395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100396       };
100397     } catch (Dali::DaliException e) {
100398       {
100399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100400       };
100401     } catch (...) {
100402       {
100403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100404       };
100405     }
100406   }
100407
100408 }
100409
100410
100411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
100412   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100413
100414   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100415   {
100416     try {
100417       (*arg1)->Unreference();
100418     } catch (std::out_of_range& e) {
100419       {
100420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100421       };
100422     } catch (std::exception& e) {
100423       {
100424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100425       };
100426     } catch (Dali::DaliException e) {
100427       {
100428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100429       };
100430     } catch (...) {
100431       {
100432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100433       };
100434     }
100435   }
100436
100437 }
100438
100439
100440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
100441   int jresult ;
100442   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100443   int result;
100444
100445   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100446   {
100447     try {
100448       result = (int)(*arg1)->ReferenceCount();
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 unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
100474   unsigned int jresult ;
100475   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100476   bool result;
100477
100478   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100479   {
100480     try {
100481       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100482     } catch (std::out_of_range& e) {
100483       {
100484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100485       };
100486     } catch (std::exception& e) {
100487       {
100488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100489       };
100490     } catch (Dali::DaliException e) {
100491       {
100492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100493       };
100494     } catch (...) {
100495       {
100496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100497       };
100498     }
100499   }
100500
100501   jresult = result;
100502   return jresult;
100503 }
100504
100505
100506 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
100507   unsigned long jresult ;
100508   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100509   std::size_t result;
100510
100511   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100512   {
100513     try {
100514       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100515     } catch (std::out_of_range& e) {
100516       {
100517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100518       };
100519     } catch (std::exception& e) {
100520       {
100521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100522       };
100523     } catch (Dali::DaliException e) {
100524       {
100525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100526       };
100527     } catch (...) {
100528       {
100529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100530       };
100531     }
100532   }
100533
100534   jresult = (unsigned long)result;
100535   return jresult;
100536 }
100537
100538
100539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
100540   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100541   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100542
100543   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100544   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100545   {
100546     try {
100547       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
100548     } catch (std::out_of_range& e) {
100549       {
100550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100551       };
100552     } catch (std::exception& e) {
100553       {
100554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100555       };
100556     } catch (Dali::DaliException e) {
100557       {
100558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100559       };
100560     } catch (...) {
100561       {
100562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100563       };
100564     }
100565   }
100566
100567 }
100568
100569
100570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
100571   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100572   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100573
100574   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100575   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100576   {
100577     try {
100578       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
100579     } catch (std::out_of_range& e) {
100580       {
100581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100582       };
100583     } catch (std::exception& e) {
100584       {
100585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100586       };
100587     } catch (Dali::DaliException e) {
100588       {
100589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100590       };
100591     } catch (...) {
100592       {
100593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100594       };
100595     }
100596   }
100597
100598 }
100599
100600
100601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
100602   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100603   Dali::Toolkit::Control arg2 ;
100604   Dali::Toolkit::Control *argp2 ;
100605
100606   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100607   argp2 = (Dali::Toolkit::Control *)jarg2;
100608   if (!argp2) {
100609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
100610     return ;
100611   }
100612   arg2 = *argp2;
100613   {
100614     try {
100615       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
100616     } catch (std::out_of_range& e) {
100617       {
100618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100619       };
100620     } catch (std::exception& e) {
100621       {
100622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100623       };
100624     } catch (Dali::DaliException e) {
100625       {
100626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100627       };
100628     } catch (...) {
100629       {
100630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100631       };
100632     }
100633   }
100634
100635 }
100636
100637
100638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
100639   void * jresult ;
100640   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
100641
100642   {
100643     try {
100644       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
100645     } catch (std::out_of_range& e) {
100646       {
100647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100648       };
100649     } catch (std::exception& e) {
100650       {
100651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100652       };
100653     } catch (Dali::DaliException e) {
100654       {
100655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100656       };
100657     } catch (...) {
100658       {
100659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100660       };
100661     }
100662   }
100663
100664   jresult = (void *)result;
100665   return jresult;
100666 }
100667
100668
100669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
100670   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100671
100672   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100673   {
100674     try {
100675       delete arg1;
100676     } catch (std::out_of_range& e) {
100677       {
100678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100679       };
100680     } catch (std::exception& e) {
100681       {
100682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100683       };
100684     } catch (Dali::DaliException e) {
100685       {
100686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100687       };
100688     } catch (...) {
100689       {
100690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100691       };
100692     }
100693   }
100694
100695 }
100696
100697 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
100698   Dali::RefObject *result = NULL;
100699
100700   if (arg1)
100701   {
100702     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
100703   }
100704   return result;
100705 }
100706
100707 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
100708     return (Dali::RefObject *)jarg1;
100709 }
100710
100711 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
100712     return (Dali::SignalObserver *)jarg1;
100713 }
100714
100715 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
100716     return (Dali::ConnectionTrackerInterface *)jarg1;
100717 }
100718
100719 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
100720     return (Dali::BaseHandle *)jarg1;
100721 }
100722
100723 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
100724     return (Dali::BaseHandle *)jarg1;
100725 }
100726
100727 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
100728     return (Dali::BaseHandle *)jarg1;
100729 }
100730
100731 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
100732     return (Dali::BaseHandle *)jarg1;
100733 }
100734
100735 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
100736     return (Dali::BaseHandle *)jarg1;
100737 }
100738
100739 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
100740     return (Dali::BaseHandle *)jarg1;
100741 }
100742
100743 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
100744     return (Dali::BaseHandle *)jarg1;
100745 }
100746
100747 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
100748     return (Dali::BaseHandle *)jarg1;
100749 }
100750
100751 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
100752     return (Dali::BaseHandle *)jarg1;
100753 }
100754
100755 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
100756     return (Dali::BaseHandle *)jarg1;
100757 }
100758
100759 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
100760     return (Dali::BaseHandle *)jarg1;
100761 }
100762
100763 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
100764     return (Dali::BaseHandle *)jarg1;
100765 }
100766
100767 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
100768     return (Dali::BaseHandle *)jarg1;
100769 }
100770
100771 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
100772     return (Dali::Handle *)jarg1;
100773 }
100774
100775 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
100776     return (Dali::Handle *)jarg1;
100777 }
100778
100779 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
100780     return (Dali::BaseHandle *)jarg1;
100781 }
100782
100783 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
100784     return (Dali::BaseHandle *)jarg1;
100785 }
100786
100787 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
100788     return (Dali::Handle *)jarg1;
100789 }
100790
100791 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
100792     return (Dali::BaseHandle *)jarg1;
100793 }
100794
100795 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
100796     return (Dali::Handle *)jarg1;
100797 }
100798
100799 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
100800     return (Dali::GestureDetector *)jarg1;
100801 }
100802
100803 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
100804     return (Dali::Gesture *)jarg1;
100805 }
100806
100807 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
100808     return (Dali::Handle *)jarg1;
100809 }
100810
100811 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
100812     return (Dali::Actor *)jarg1;
100813 }
100814
100815 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
100816     return (Dali::BaseHandle *)jarg1;
100817 }
100818
100819 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
100820     return (Dali::RefObject *)jarg1;
100821 }
100822
100823 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
100824     return (Dali::Actor *)jarg1;
100825 }
100826
100827 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
100828     return (Dali::GestureDetector *)jarg1;
100829 }
100830
100831 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
100832     return (Dali::Gesture *)jarg1;
100833 }
100834
100835 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
100836     return (Dali::GestureDetector *)jarg1;
100837 }
100838
100839 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
100840     return (Dali::Gesture *)jarg1;
100841 }
100842
100843 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
100844     return (Dali::GestureDetector *)jarg1;
100845 }
100846
100847 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
100848     return (Dali::Gesture *)jarg1;
100849 }
100850
100851 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
100852     return (Dali::BaseHandle *)jarg1;
100853 }
100854
100855 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
100856     return (Dali::Handle *)jarg1;
100857 }
100858
100859 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
100860     return (Dali::Handle *)jarg1;
100861 }
100862
100863 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
100864     return (Dali::Handle *)jarg1;
100865 }
100866
100867 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
100868     return (Dali::Image *)jarg1;
100869 }
100870
100871 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
100872     return (Dali::Image *)jarg1;
100873 }
100874
100875 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
100876     return (Dali::Image *)jarg1;
100877 }
100878
100879 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
100880     return (Dali::RefObject *)jarg1;
100881 }
100882
100883 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
100884     return (Dali::Image *)jarg1;
100885 }
100886
100887 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
100888     return (Dali::Image *)jarg1;
100889 }
100890
100891 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
100892     return (Dali::ResourceImage *)jarg1;
100893 }
100894
100895 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
100896     return (Dali::Actor *)jarg1;
100897 }
100898
100899 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
100900     return (Dali::BaseHandle *)jarg1;
100901 }
100902
100903 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
100904     return (Dali::BaseHandle *)jarg1;
100905 }
100906
100907
100908 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
100909     return (Dali::BaseHandle *)jarg1;
100910 }
100911
100912 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
100913     return (Dali::BaseHandle *)jarg1;
100914 }
100915
100916 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
100917     return (Dali::CustomActorImpl *)jarg1;
100918 }
100919
100920 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
100921     return (Dali::CustomActor *)jarg1;
100922 }
100923
100924 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
100925     return (Dali::BaseHandle *)jarg1;
100926 }
100927
100928 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
100929     return (Dali::Toolkit::Control *)jarg1;
100930 }
100931
100932 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
100933     return (Dali::Toolkit::Control *)jarg1;
100934 }
100935
100936 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
100937     return (Dali::Toolkit::Button *)jarg1;
100938 }
100939
100940 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
100941     return (Dali::Toolkit::Button *)jarg1;
100942 }
100943
100944 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
100945     return (Dali::Toolkit::Button *)jarg1;
100946 }
100947
100948 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
100949     return (Dali::Toolkit::Control *)jarg1;
100950 }
100951
100952 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
100953     return (Dali::Toolkit::Control *)jarg1;
100954 }
100955
100956 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
100957     return (Dali::Toolkit::Control *)jarg1;
100958 }
100959
100960 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
100961     return (Dali::Toolkit::Control *)jarg1;
100962 }
100963
100964 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
100965     return (Dali::Toolkit::Control *)jarg1;
100966 }
100967
100968 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
100969     return (Dali::RefObject *)jarg1;
100970 }
100971
100972 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
100973     return (Dali::Toolkit::Scrollable *)jarg1;
100974 }
100975
100976 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
100977     return (Dali::BaseHandle *)jarg1;
100978 }
100979
100980 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
100981     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
100982 }
100983
100984 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
100985     return (Dali::RefObject *)jarg1;
100986 }
100987
100988 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
100989     return (Dali::Toolkit::Ruler *)jarg1;
100990 }
100991
100992 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
100993     return (Dali::Toolkit::Ruler *)jarg1;
100994 }
100995
100996 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
100997     return (Dali::Toolkit::Scrollable *)jarg1;
100998 }
100999
101000 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
101001     return (Dali::Toolkit::Control *)jarg1;
101002 }
101003
101004
101005 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
101006     return (Dali::Toolkit::Control *)jarg1;
101007 }
101008
101009 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
101010     return (Dali::BaseHandle *)jarg1;
101011 }
101012
101013 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
101014     return (Dali::BaseHandle *)jarg1;
101015 }
101016
101017 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
101018     return (Dali::Toolkit::Control *)jarg1;
101019 }
101020
101021 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
101022     return (Dali::Toolkit::Control *)jarg1;
101023 }
101024
101025 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
101026     return (Dali::Toolkit::Control *)jarg1;
101027 }
101028
101029 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
101030     return (Dali::Toolkit::Control *)jarg1;
101031 }
101032
101033 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
101034     return (Dali::Toolkit::Control *)jarg1;
101035 }
101036
101037 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
101038     return (Dali::Toolkit::Control *)jarg1;
101039 }
101040
101041 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
101042     return (Dali::Toolkit::PageTurnView *)jarg1;
101043 }
101044
101045 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
101046     return (Dali::Toolkit::PageTurnView *)jarg1;
101047 }
101048
101049 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
101050     return (Dali::Toolkit::Button *)jarg1;
101051 }
101052
101053 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
101054     return (Dali::BaseHandle *)jarg1;
101055 }
101056
101057 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
101058     return (Dali::BaseHandle *)jarg1;
101059 }
101060
101061 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
101062     return (Dali::BaseHandle *)jarg1;
101063 }
101064
101065
101066 #ifdef __cplusplus
101067 }
101068 #endif
101069