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::ImageVisual::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::ImageVisual::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::ImageVisual::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::Property::Index arg2 = 0 ;
68157   arg2 = (Dali::Property::Index)jarg2;
68158
68159   Toolkit::Visual::ResourceStatus result;
68160   {
68161     try {
68162       result = arg1->GetVisualResourceStatus(arg2);
68163     } catch (std::out_of_range& e) {
68164       {
68165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68166       };
68167     } catch (std::exception& e) {
68168       {
68169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68170       };
68171     } catch (...) {
68172       {
68173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68174       };
68175     }
68176   }
68177   jresult = (int)(result);
68178   return jresult;
68179 }
68180
68181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
68182 {
68183   void * jresult;
68184   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68185   arg1 = (Dali::Toolkit::Control *)jarg1;
68186
68187   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
68188
68189   Dali::Toolkit::TransitionData *arg2 = 0 ;
68190   Dali::Animation result;
68191
68192   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
68193   if (!arg2) {
68194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
68195     return 0;
68196   }
68197   {
68198     try {
68199       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
68200     } catch (std::out_of_range& e) {
68201       {
68202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68203       };
68204     } catch (std::exception& e) {
68205       {
68206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68207       };
68208     } catch (Dali::DaliException e) {
68209       {
68210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68211       };
68212     } catch (...) {
68213       {
68214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68215       };
68216     }
68217   }
68218
68219   jresult = new Dali::Animation((const Dali::Animation &)result);
68220   return jresult;
68221 }
68222
68223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
68224 {
68225   Dali::Toolkit::Control arg1;
68226   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
68227
68228   if (!argp1) {
68229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68230   }
68231   arg1 = *argp1;
68232
68233   Dali::Property::Index arg2 = 0 ;
68234   arg2 = (Dali::Property::Index)jarg2;
68235
68236   Dali::Property::Index arg3 = 0 ;
68237   arg3 = (Dali::Property::Index)jarg3;
68238
68239   Dali::Property::Value arg4;
68240   arg4 = (Dali::Property::Value *)jarg4;
68241
68242   {
68243     try {
68244       DevelControl::DoAction(arg1, arg2, arg3, arg4);
68245     } catch (std::out_of_range& e) {
68246       {
68247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68248       };
68249     } catch (std::exception& e) {
68250       {
68251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68252       };
68253     } catch (...) {
68254       {
68255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68256       };
68257     }
68258   }
68259
68260
68261 }
68262
68263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
68264   void * jresult ;
68265   Dali::Toolkit::Control *arg1 = 0 ;
68266   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
68267
68268   arg1 = (Dali::Toolkit::Control *)jarg1;
68269   if (!arg1) {
68270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68271     return 0;
68272   }
68273   {
68274     try {
68275       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
68276     } catch (std::out_of_range& e) {
68277       {
68278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68279       };
68280     } catch (std::exception& e) {
68281       {
68282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68283       };
68284     } catch (Dali::DaliException e) {
68285       {
68286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68287       };
68288     } catch (...) {
68289       {
68290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68291       };
68292     }
68293   }
68294
68295   jresult = (void *)result;
68296   return jresult;
68297 }
68298
68299
68300 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
68301   unsigned int jresult ;
68302   Dali::Toolkit::Control *arg1 = 0 ;
68303   bool result;
68304
68305   arg1 = (Dali::Toolkit::Control *)jarg1;
68306   if (!arg1) {
68307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
68308     return 0;
68309   }
68310   {
68311     try {
68312       result = (bool)arg1->IsResourceReady();
68313     } catch (std::out_of_range& e) {
68314       {
68315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68316       };
68317     } catch (std::exception& e) {
68318       {
68319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68320       };
68321     } catch (Dali::DaliException e) {
68322       {
68323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68324       };
68325     } catch (...) {
68326       {
68327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68328       };
68329     }
68330   }
68331
68332   jresult = result;
68333   return jresult;
68334 }
68335
68336
68337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
68338   void * jresult ;
68339   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
68340
68341   {
68342     try {
68343       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
68344     } catch (std::out_of_range& e) {
68345       {
68346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68347       };
68348     } catch (std::exception& e) {
68349       {
68350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68351       };
68352     } catch (Dali::DaliException e) {
68353       {
68354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68355       };
68356     } catch (...) {
68357       {
68358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68359       };
68360     }
68361   }
68362
68363   jresult = (void *)result;
68364   return jresult;
68365 }
68366
68367
68368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
68369   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68370
68371   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68372   {
68373     try {
68374       delete arg1;
68375     } catch (std::out_of_range& e) {
68376       {
68377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68378       };
68379     } catch (std::exception& e) {
68380       {
68381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68382       };
68383     } catch (Dali::DaliException e) {
68384       {
68385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68386       };
68387     } catch (...) {
68388       {
68389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68390       };
68391     }
68392   }
68393
68394 }
68395
68396
68397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
68398   void * jresult ;
68399   Dali::Toolkit::KeyInputFocusManager result;
68400
68401   {
68402     try {
68403       result = Dali::Toolkit::KeyInputFocusManager::Get();
68404     } catch (std::out_of_range& e) {
68405       {
68406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68407       };
68408     } catch (std::exception& e) {
68409       {
68410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68411       };
68412     } catch (Dali::DaliException e) {
68413       {
68414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68415       };
68416     } catch (...) {
68417       {
68418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68419       };
68420     }
68421   }
68422
68423   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
68424   return jresult;
68425 }
68426
68427
68428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
68429   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68430   Dali::Toolkit::Control arg2 ;
68431   Dali::Toolkit::Control *argp2 ;
68432
68433   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68434   argp2 = (Dali::Toolkit::Control *)jarg2;
68435   if (!argp2) {
68436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68437     return ;
68438   }
68439   arg2 = *argp2;
68440   {
68441     try {
68442       (arg1)->SetFocus(arg2);
68443     } catch (std::out_of_range& e) {
68444       {
68445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68446       };
68447     } catch (std::exception& e) {
68448       {
68449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68450       };
68451     } catch (Dali::DaliException e) {
68452       {
68453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68454       };
68455     } catch (...) {
68456       {
68457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68458       };
68459     }
68460   }
68461
68462 }
68463
68464
68465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
68466   void * jresult ;
68467   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68468   Dali::Toolkit::Control result;
68469
68470   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68471   {
68472     try {
68473       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
68474     } catch (std::out_of_range& e) {
68475       {
68476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68477       };
68478     } catch (std::exception& e) {
68479       {
68480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68481       };
68482     } catch (Dali::DaliException e) {
68483       {
68484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68485       };
68486     } catch (...) {
68487       {
68488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68489       };
68490     }
68491   }
68492
68493   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
68494   return jresult;
68495 }
68496
68497
68498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
68499   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68500   Dali::Toolkit::Control arg2 ;
68501   Dali::Toolkit::Control *argp2 ;
68502
68503   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68504   argp2 = (Dali::Toolkit::Control *)jarg2;
68505   if (!argp2) {
68506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68507     return ;
68508   }
68509   arg2 = *argp2;
68510   {
68511     try {
68512       (arg1)->RemoveFocus(arg2);
68513     } catch (std::out_of_range& e) {
68514       {
68515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68516       };
68517     } catch (std::exception& e) {
68518       {
68519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68520       };
68521     } catch (Dali::DaliException e) {
68522       {
68523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68524       };
68525     } catch (...) {
68526       {
68527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68528       };
68529     }
68530   }
68531
68532 }
68533
68534
68535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
68536   void * jresult ;
68537   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68538   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
68539
68540   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68541   {
68542     try {
68543       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
68544     } catch (std::out_of_range& e) {
68545       {
68546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68547       };
68548     } catch (std::exception& e) {
68549       {
68550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68551       };
68552     } catch (Dali::DaliException e) {
68553       {
68554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68555       };
68556     } catch (...) {
68557       {
68558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68559       };
68560     }
68561   }
68562
68563   jresult = (void *)result;
68564   return jresult;
68565 }
68566
68567
68568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
68569   void * jresult ;
68570   Dali::Toolkit::Alignment::Padding *result = 0 ;
68571
68572   {
68573     try {
68574       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
68575     } catch (std::out_of_range& e) {
68576       {
68577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68578       };
68579     } catch (std::exception& e) {
68580       {
68581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68582       };
68583     } catch (Dali::DaliException e) {
68584       {
68585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68586       };
68587     } catch (...) {
68588       {
68589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68590       };
68591     }
68592   }
68593
68594   jresult = (void *)result;
68595   return jresult;
68596 }
68597
68598
68599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
68600   void * jresult ;
68601   float arg1 ;
68602   float arg2 ;
68603   float arg3 ;
68604   float arg4 ;
68605   Dali::Toolkit::Alignment::Padding *result = 0 ;
68606
68607   arg1 = (float)jarg1;
68608   arg2 = (float)jarg2;
68609   arg3 = (float)jarg3;
68610   arg4 = (float)jarg4;
68611   {
68612     try {
68613       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
68614     } catch (std::out_of_range& e) {
68615       {
68616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68617       };
68618     } catch (std::exception& e) {
68619       {
68620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68621       };
68622     } catch (Dali::DaliException e) {
68623       {
68624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68625       };
68626     } catch (...) {
68627       {
68628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68629       };
68630     }
68631   }
68632
68633   jresult = (void *)result;
68634   return jresult;
68635 }
68636
68637
68638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
68639   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68640   float arg2 ;
68641
68642   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68643   arg2 = (float)jarg2;
68644   if (arg1) (arg1)->left = arg2;
68645 }
68646
68647
68648 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
68649   float jresult ;
68650   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68651   float result;
68652
68653   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68654   result = (float) ((arg1)->left);
68655   jresult = result;
68656   return jresult;
68657 }
68658
68659
68660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
68661   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68662   float arg2 ;
68663
68664   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68665   arg2 = (float)jarg2;
68666   if (arg1) (arg1)->right = arg2;
68667 }
68668
68669
68670 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
68671   float jresult ;
68672   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68673   float result;
68674
68675   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68676   result = (float) ((arg1)->right);
68677   jresult = result;
68678   return jresult;
68679 }
68680
68681
68682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
68683   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68684   float arg2 ;
68685
68686   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68687   arg2 = (float)jarg2;
68688   if (arg1) (arg1)->top = arg2;
68689 }
68690
68691
68692 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
68693   float jresult ;
68694   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68695   float result;
68696
68697   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68698   result = (float) ((arg1)->top);
68699   jresult = result;
68700   return jresult;
68701 }
68702
68703
68704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
68705   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68706   float arg2 ;
68707
68708   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68709   arg2 = (float)jarg2;
68710   if (arg1) (arg1)->bottom = arg2;
68711 }
68712
68713
68714 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
68715   float jresult ;
68716   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68717   float result;
68718
68719   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68720   result = (float) ((arg1)->bottom);
68721   jresult = result;
68722   return jresult;
68723 }
68724
68725
68726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
68727   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68728
68729   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68730   {
68731     try {
68732       delete arg1;
68733     } catch (std::out_of_range& e) {
68734       {
68735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68736       };
68737     } catch (std::exception& e) {
68738       {
68739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68740       };
68741     } catch (Dali::DaliException e) {
68742       {
68743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68744       };
68745     } catch (...) {
68746       {
68747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68748       };
68749     }
68750   }
68751
68752 }
68753
68754
68755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
68756   void * jresult ;
68757   Dali::Toolkit::Alignment *result = 0 ;
68758
68759   {
68760     try {
68761       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
68762     } catch (std::out_of_range& e) {
68763       {
68764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68765       };
68766     } catch (std::exception& e) {
68767       {
68768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68769       };
68770     } catch (Dali::DaliException e) {
68771       {
68772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68773       };
68774     } catch (...) {
68775       {
68776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68777       };
68778     }
68779   }
68780
68781   jresult = (void *)result;
68782   return jresult;
68783 }
68784
68785
68786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
68787   void * jresult ;
68788   Dali::Toolkit::Alignment::Type arg1 ;
68789   Dali::Toolkit::Alignment::Type arg2 ;
68790   Dali::Toolkit::Alignment result;
68791
68792   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68793   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68794   {
68795     try {
68796       result = Dali::Toolkit::Alignment::New(arg1,arg2);
68797     } catch (std::out_of_range& e) {
68798       {
68799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68800       };
68801     } catch (std::exception& e) {
68802       {
68803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68804       };
68805     } catch (Dali::DaliException e) {
68806       {
68807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68808       };
68809     } catch (...) {
68810       {
68811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68812       };
68813     }
68814   }
68815
68816   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68817   return jresult;
68818 }
68819
68820
68821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
68822   void * jresult ;
68823   Dali::Toolkit::Alignment::Type arg1 ;
68824   Dali::Toolkit::Alignment result;
68825
68826   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68827   {
68828     try {
68829       result = Dali::Toolkit::Alignment::New(arg1);
68830     } catch (std::out_of_range& e) {
68831       {
68832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68833       };
68834     } catch (std::exception& e) {
68835       {
68836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68837       };
68838     } catch (Dali::DaliException e) {
68839       {
68840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68841       };
68842     } catch (...) {
68843       {
68844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68845       };
68846     }
68847   }
68848
68849   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68850   return jresult;
68851 }
68852
68853
68854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
68855   void * jresult ;
68856   Dali::Toolkit::Alignment result;
68857
68858   {
68859     try {
68860       result = Dali::Toolkit::Alignment::New();
68861     } catch (std::out_of_range& e) {
68862       {
68863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68864       };
68865     } catch (std::exception& e) {
68866       {
68867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68868       };
68869     } catch (Dali::DaliException e) {
68870       {
68871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68872       };
68873     } catch (...) {
68874       {
68875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68876       };
68877     }
68878   }
68879
68880   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68881   return jresult;
68882 }
68883
68884
68885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
68886   void * jresult ;
68887   Dali::Toolkit::Alignment *arg1 = 0 ;
68888   Dali::Toolkit::Alignment *result = 0 ;
68889
68890   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68891   if (!arg1) {
68892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
68893     return 0;
68894   }
68895   {
68896     try {
68897       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
68898     } catch (std::out_of_range& e) {
68899       {
68900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68901       };
68902     } catch (std::exception& e) {
68903       {
68904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68905       };
68906     } catch (Dali::DaliException e) {
68907       {
68908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68909       };
68910     } catch (...) {
68911       {
68912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68913       };
68914     }
68915   }
68916
68917   jresult = (void *)result;
68918   return jresult;
68919 }
68920
68921
68922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
68923   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68924
68925   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68926   {
68927     try {
68928       delete arg1;
68929     } catch (std::out_of_range& e) {
68930       {
68931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68932       };
68933     } catch (std::exception& e) {
68934       {
68935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68936       };
68937     } catch (Dali::DaliException e) {
68938       {
68939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68940       };
68941     } catch (...) {
68942       {
68943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68944       };
68945     }
68946   }
68947
68948 }
68949
68950
68951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
68952   void * jresult ;
68953   Dali::BaseHandle arg1 ;
68954   Dali::BaseHandle *argp1 ;
68955   Dali::Toolkit::Alignment result;
68956
68957   argp1 = (Dali::BaseHandle *)jarg1;
68958   if (!argp1) {
68959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68960     return 0;
68961   }
68962   arg1 = *argp1;
68963   {
68964     try {
68965       result = Dali::Toolkit::Alignment::DownCast(arg1);
68966     } catch (std::out_of_range& e) {
68967       {
68968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68969       };
68970     } catch (std::exception& e) {
68971       {
68972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68973       };
68974     } catch (Dali::DaliException e) {
68975       {
68976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68977       };
68978     } catch (...) {
68979       {
68980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68981       };
68982     }
68983   }
68984
68985   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68986   return jresult;
68987 }
68988
68989
68990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
68991   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68992   Dali::Toolkit::Alignment::Type arg2 ;
68993
68994   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68995   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68996   {
68997     try {
68998       (arg1)->SetAlignmentType(arg2);
68999     } catch (std::out_of_range& e) {
69000       {
69001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69002       };
69003     } catch (std::exception& e) {
69004       {
69005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69006       };
69007     } catch (Dali::DaliException e) {
69008       {
69009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69010       };
69011     } catch (...) {
69012       {
69013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69014       };
69015     }
69016   }
69017
69018 }
69019
69020
69021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
69022   int jresult ;
69023   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69024   Dali::Toolkit::Alignment::Type result;
69025
69026   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69027   {
69028     try {
69029       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
69030     } catch (std::out_of_range& e) {
69031       {
69032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69033       };
69034     } catch (std::exception& e) {
69035       {
69036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69037       };
69038     } catch (Dali::DaliException e) {
69039       {
69040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69041       };
69042     } catch (...) {
69043       {
69044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69045       };
69046     }
69047   }
69048
69049   jresult = (int)result;
69050   return jresult;
69051 }
69052
69053
69054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
69055   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69056   Dali::Toolkit::Alignment::Scaling arg2 ;
69057
69058   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69059   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
69060   {
69061     try {
69062       (arg1)->SetScaling(arg2);
69063     } catch (std::out_of_range& e) {
69064       {
69065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69066       };
69067     } catch (std::exception& e) {
69068       {
69069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69070       };
69071     } catch (Dali::DaliException e) {
69072       {
69073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69074       };
69075     } catch (...) {
69076       {
69077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69078       };
69079     }
69080   }
69081
69082 }
69083
69084
69085 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
69086   int jresult ;
69087   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69088   Dali::Toolkit::Alignment::Scaling result;
69089
69090   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69091   {
69092     try {
69093       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
69094     } catch (std::out_of_range& e) {
69095       {
69096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69097       };
69098     } catch (std::exception& e) {
69099       {
69100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69101       };
69102     } catch (Dali::DaliException e) {
69103       {
69104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69105       };
69106     } catch (...) {
69107       {
69108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69109       };
69110     }
69111   }
69112
69113   jresult = (int)result;
69114   return jresult;
69115 }
69116
69117
69118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
69119   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69120   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
69121
69122   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69123   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
69124   if (!arg2) {
69125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
69126     return ;
69127   }
69128   {
69129     try {
69130       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
69131     } catch (std::out_of_range& e) {
69132       {
69133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69134       };
69135     } catch (std::exception& e) {
69136       {
69137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69138       };
69139     } catch (Dali::DaliException e) {
69140       {
69141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69142       };
69143     } catch (...) {
69144       {
69145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69146       };
69147     }
69148   }
69149
69150 }
69151
69152
69153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
69154   void * jresult ;
69155   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69156   Dali::Toolkit::Alignment::Padding *result = 0 ;
69157
69158   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69159   {
69160     try {
69161       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
69162     } catch (std::out_of_range& e) {
69163       {
69164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69165       };
69166     } catch (std::exception& e) {
69167       {
69168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69169       };
69170     } catch (Dali::DaliException e) {
69171       {
69172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69173       };
69174     } catch (...) {
69175       {
69176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69177       };
69178     }
69179   }
69180
69181   jresult = (void *)result;
69182   return jresult;
69183 }
69184
69185
69186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
69187   void * jresult ;
69188   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69189   Dali::Toolkit::Alignment *arg2 = 0 ;
69190   Dali::Toolkit::Alignment *result = 0 ;
69191
69192   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69193   arg2 = (Dali::Toolkit::Alignment *)jarg2;
69194   if (!arg2) {
69195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
69196     return 0;
69197   }
69198   {
69199     try {
69200       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
69201     } catch (std::out_of_range& e) {
69202       {
69203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69204       };
69205     } catch (std::exception& e) {
69206       {
69207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69208       };
69209     } catch (Dali::DaliException e) {
69210       {
69211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69212       };
69213     } catch (...) {
69214       {
69215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69216       };
69217     }
69218   }
69219
69220   jresult = (void *)result;
69221   return jresult;
69222 }
69223
69224
69225 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
69226   int jresult ;
69227   int result;
69228
69229   result = (int)Dali::Toolkit::Button::Property::DISABLED;
69230   jresult = (int)result;
69231   return jresult;
69232 }
69233
69234
69235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
69236   int jresult ;
69237   int result;
69238
69239   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
69240   jresult = (int)result;
69241   return jresult;
69242 }
69243
69244
69245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
69246   int jresult ;
69247   int result;
69248
69249   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
69250   jresult = (int)result;
69251   return jresult;
69252 }
69253
69254
69255 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
69256   int jresult ;
69257   int result;
69258
69259   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
69260   jresult = (int)result;
69261   return jresult;
69262 }
69263
69264
69265 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
69266   int jresult ;
69267   int result;
69268
69269   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
69270   jresult = (int)result;
69271   return jresult;
69272 }
69273
69274
69275 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
69276   int jresult ;
69277   int result;
69278
69279   result = (int)Dali::Toolkit::Button::Property::SELECTED;
69280   jresult = (int)result;
69281   return jresult;
69282 }
69283
69284
69285 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
69286   int jresult ;
69287   int result;
69288
69289   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
69290   jresult = (int)result;
69291   return jresult;
69292 }
69293
69294
69295 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
69296   int jresult ;
69297   int result;
69298
69299   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
69300   jresult = (int)result;
69301   return jresult;
69302 }
69303
69304
69305 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
69306   int jresult ;
69307   int result;
69308
69309   result = (int)Dali::Toolkit::Button::Property::LABEL;
69310   jresult = (int)result;
69311   return jresult;
69312 }
69313
69314
69315 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
69316   int jresult ;
69317   int result;
69318
69319   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
69320   jresult = (int)result;
69321   return jresult;
69322 }
69323
69324
69325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
69326   void * jresult ;
69327   Dali::Toolkit::Button::Property *result = 0 ;
69328
69329   {
69330     try {
69331       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
69332     } catch (std::out_of_range& e) {
69333       {
69334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69335       };
69336     } catch (std::exception& e) {
69337       {
69338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69339       };
69340     } catch (Dali::DaliException e) {
69341       {
69342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69343       };
69344     } catch (...) {
69345       {
69346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69347       };
69348     }
69349   }
69350
69351   jresult = (void *)result;
69352   return jresult;
69353 }
69354
69355
69356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
69357   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
69358
69359   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
69360   {
69361     try {
69362       delete arg1;
69363     } catch (std::out_of_range& e) {
69364       {
69365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69366       };
69367     } catch (std::exception& e) {
69368       {
69369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69370       };
69371     } catch (Dali::DaliException e) {
69372       {
69373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69374       };
69375     } catch (...) {
69376       {
69377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69378       };
69379     }
69380   }
69381
69382 }
69383
69384
69385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
69386   void * jresult ;
69387   Dali::Toolkit::Button *result = 0 ;
69388
69389   {
69390     try {
69391       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
69392     } catch (std::out_of_range& e) {
69393       {
69394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69395       };
69396     } catch (std::exception& e) {
69397       {
69398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69399       };
69400     } catch (Dali::DaliException e) {
69401       {
69402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69403       };
69404     } catch (...) {
69405       {
69406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69407       };
69408     }
69409   }
69410
69411   jresult = (void *)result;
69412   return jresult;
69413 }
69414
69415
69416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
69417   void * jresult ;
69418   Dali::Toolkit::Button *arg1 = 0 ;
69419   Dali::Toolkit::Button *result = 0 ;
69420
69421   arg1 = (Dali::Toolkit::Button *)jarg1;
69422   if (!arg1) {
69423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69424     return 0;
69425   }
69426   {
69427     try {
69428       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
69429     } catch (std::out_of_range& e) {
69430       {
69431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69432       };
69433     } catch (std::exception& e) {
69434       {
69435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69436       };
69437     } catch (Dali::DaliException e) {
69438       {
69439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69440       };
69441     } catch (...) {
69442       {
69443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69444       };
69445     }
69446   }
69447
69448   jresult = (void *)result;
69449   return jresult;
69450 }
69451
69452
69453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
69454   void * jresult ;
69455   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69456   Dali::Toolkit::Button *arg2 = 0 ;
69457   Dali::Toolkit::Button *result = 0 ;
69458
69459   arg1 = (Dali::Toolkit::Button *)jarg1;
69460   arg2 = (Dali::Toolkit::Button *)jarg2;
69461   if (!arg2) {
69462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69463     return 0;
69464   }
69465   {
69466     try {
69467       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
69468     } catch (std::out_of_range& e) {
69469       {
69470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69471       };
69472     } catch (std::exception& e) {
69473       {
69474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69475       };
69476     } catch (Dali::DaliException e) {
69477       {
69478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69479       };
69480     } catch (...) {
69481       {
69482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69483       };
69484     }
69485   }
69486
69487   jresult = (void *)result;
69488   return jresult;
69489 }
69490
69491
69492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
69493   void * jresult ;
69494   Dali::BaseHandle arg1 ;
69495   Dali::BaseHandle *argp1 ;
69496   Dali::Toolkit::Button result;
69497
69498   argp1 = (Dali::BaseHandle *)jarg1;
69499   if (!argp1) {
69500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69501     return 0;
69502   }
69503   arg1 = *argp1;
69504   {
69505     try {
69506       result = Dali::Toolkit::Button::DownCast(arg1);
69507     } catch (std::out_of_range& e) {
69508       {
69509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69510       };
69511     } catch (std::exception& e) {
69512       {
69513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69514       };
69515     } catch (Dali::DaliException e) {
69516       {
69517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69518       };
69519     } catch (...) {
69520       {
69521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69522       };
69523     }
69524   }
69525
69526   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
69527   return jresult;
69528 }
69529
69530
69531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
69532   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69533
69534   arg1 = (Dali::Toolkit::Button *)jarg1;
69535   {
69536     try {
69537       delete arg1;
69538     } catch (std::out_of_range& e) {
69539       {
69540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69541       };
69542     } catch (std::exception& e) {
69543       {
69544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69545       };
69546     } catch (Dali::DaliException e) {
69547       {
69548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69549       };
69550     } catch (...) {
69551       {
69552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69553       };
69554     }
69555   }
69556
69557 }
69558
69559
69560 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
69561   unsigned int jresult ;
69562   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69563   bool result;
69564
69565   arg1 = (Dali::Toolkit::Button *)jarg1;
69566   {
69567     try {
69568       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
69569     } catch (std::out_of_range& e) {
69570       {
69571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69572       };
69573     } catch (std::exception& e) {
69574       {
69575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69576       };
69577     } catch (Dali::DaliException e) {
69578       {
69579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69580       };
69581     } catch (...) {
69582       {
69583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69584       };
69585     }
69586   }
69587
69588   jresult = result;
69589   return jresult;
69590 }
69591
69592
69593 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
69594   unsigned int jresult ;
69595   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69596   bool result;
69597
69598   arg1 = (Dali::Toolkit::Button *)jarg1;
69599   {
69600     try {
69601       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
69602     } catch (std::out_of_range& e) {
69603       {
69604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69605       };
69606     } catch (std::exception& e) {
69607       {
69608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69609       };
69610     } catch (Dali::DaliException e) {
69611       {
69612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69613       };
69614     } catch (...) {
69615       {
69616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69617       };
69618     }
69619   }
69620
69621   jresult = result;
69622   return jresult;
69623 }
69624
69625
69626 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
69627   float jresult ;
69628   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69629   float result;
69630
69631   arg1 = (Dali::Toolkit::Button *)jarg1;
69632   {
69633     try {
69634       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
69635     } catch (std::out_of_range& e) {
69636       {
69637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69638       };
69639     } catch (std::exception& e) {
69640       {
69641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69642       };
69643     } catch (Dali::DaliException e) {
69644       {
69645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69646       };
69647     } catch (...) {
69648       {
69649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69650       };
69651     }
69652   }
69653
69654   jresult = result;
69655   return jresult;
69656 }
69657
69658
69659 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
69660   float jresult ;
69661   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69662   float result;
69663
69664   arg1 = (Dali::Toolkit::Button *)jarg1;
69665   {
69666     try {
69667       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
69668     } catch (std::out_of_range& e) {
69669       {
69670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69671       };
69672     } catch (std::exception& e) {
69673       {
69674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69675       };
69676     } catch (Dali::DaliException e) {
69677       {
69678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69679       };
69680     } catch (...) {
69681       {
69682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69683       };
69684     }
69685   }
69686
69687   jresult = result;
69688   return jresult;
69689 }
69690
69691
69692 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
69693   unsigned int jresult ;
69694   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69695   bool result;
69696
69697   arg1 = (Dali::Toolkit::Button *)jarg1;
69698   {
69699     try {
69700       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
69701     } catch (std::out_of_range& e) {
69702       {
69703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69704       };
69705     } catch (std::exception& e) {
69706       {
69707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69708       };
69709     } catch (Dali::DaliException e) {
69710       {
69711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69712       };
69713     } catch (...) {
69714       {
69715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69716       };
69717     }
69718   }
69719
69720   jresult = result;
69721   return jresult;
69722 }
69723
69724
69725 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
69726   unsigned int jresult ;
69727   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69728   bool result;
69729
69730   arg1 = (Dali::Toolkit::Button *)jarg1;
69731   {
69732     try {
69733       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
69734     } catch (std::out_of_range& e) {
69735       {
69736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69737       };
69738     } catch (std::exception& e) {
69739       {
69740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69741       };
69742     } catch (Dali::DaliException e) {
69743       {
69744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69745       };
69746     } catch (...) {
69747       {
69748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69749       };
69750     }
69751   }
69752
69753   jresult = result;
69754   return jresult;
69755 }
69756
69757
69758 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
69759   float jresult ;
69760   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69761   float result;
69762
69763   arg1 = (Dali::Toolkit::Button *)jarg1;
69764   {
69765     try {
69766       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
69767     } catch (std::out_of_range& e) {
69768       {
69769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69770       };
69771     } catch (std::exception& e) {
69772       {
69773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69774       };
69775     } catch (Dali::DaliException e) {
69776       {
69777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69778       };
69779     } catch (...) {
69780       {
69781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69782       };
69783     }
69784   }
69785
69786   jresult = result;
69787   return jresult;
69788 }
69789
69790
69791 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
69792   char * jresult ;
69793   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69794   std::string result;
69795
69796   arg1 = (Dali::Toolkit::Button *)jarg1;
69797   {
69798     try {
69799       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
69800     } catch (std::out_of_range& e) {
69801       {
69802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69803       };
69804     } catch (std::exception& e) {
69805       {
69806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69807       };
69808     } catch (Dali::DaliException e) {
69809       {
69810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69811       };
69812     } catch (...) {
69813       {
69814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69815       };
69816     }
69817   }
69818
69819   jresult = SWIG_csharp_string_callback((&result)->c_str());
69820   return jresult;
69821 }
69822
69823
69824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
69825   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69826   Dali::Actor arg2 ;
69827   Dali::Actor *argp2 ;
69828
69829   arg1 = (Dali::Toolkit::Button *)jarg1;
69830   argp2 = (Dali::Actor *)jarg2;
69831   if (!argp2) {
69832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
69833     return ;
69834   }
69835   arg2 = *argp2;
69836   {
69837     try {
69838       (arg1)->SetLabel(arg2);
69839     } catch (std::out_of_range& e) {
69840       {
69841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69842       };
69843     } catch (std::exception& e) {
69844       {
69845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69846       };
69847     } catch (Dali::DaliException e) {
69848       {
69849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69850       };
69851     } catch (...) {
69852       {
69853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69854       };
69855     }
69856   }
69857
69858 }
69859
69860
69861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
69862   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69863   Dali::Image arg2 ;
69864   Dali::Image *argp2 ;
69865
69866   arg1 = (Dali::Toolkit::Button *)jarg1;
69867   argp2 = (Dali::Image *)jarg2;
69868   if (!argp2) {
69869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
69870     return ;
69871   }
69872   arg2 = *argp2;
69873   {
69874     try {
69875       (arg1)->SetButtonImage(arg2);
69876     } catch (std::out_of_range& e) {
69877       {
69878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69879       };
69880     } catch (std::exception& e) {
69881       {
69882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69883       };
69884     } catch (Dali::DaliException e) {
69885       {
69886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69887       };
69888     } catch (...) {
69889       {
69890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69891       };
69892     }
69893   }
69894
69895 }
69896
69897
69898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
69899   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69900   Dali::Image arg2 ;
69901   Dali::Image *argp2 ;
69902
69903   arg1 = (Dali::Toolkit::Button *)jarg1;
69904   argp2 = (Dali::Image *)jarg2;
69905   if (!argp2) {
69906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
69907     return ;
69908   }
69909   arg2 = *argp2;
69910   {
69911     try {
69912       (arg1)->SetSelectedImage(arg2);
69913     } catch (std::out_of_range& e) {
69914       {
69915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69916       };
69917     } catch (std::exception& e) {
69918       {
69919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69920       };
69921     } catch (Dali::DaliException e) {
69922       {
69923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69924       };
69925     } catch (...) {
69926       {
69927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69928       };
69929     }
69930   }
69931
69932 }
69933
69934
69935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
69936   void * jresult ;
69937   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69938   Dali::Actor result;
69939
69940   arg1 = (Dali::Toolkit::Button *)jarg1;
69941   {
69942     try {
69943       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
69944     } catch (std::out_of_range& e) {
69945       {
69946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69947       };
69948     } catch (std::exception& e) {
69949       {
69950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69951       };
69952     } catch (Dali::DaliException e) {
69953       {
69954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69955       };
69956     } catch (...) {
69957       {
69958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69959       };
69960     }
69961   }
69962
69963   jresult = new Dali::Actor((const Dali::Actor &)result);
69964   return jresult;
69965 }
69966
69967
69968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
69969   void * jresult ;
69970   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69971   Dali::Actor result;
69972
69973   arg1 = (Dali::Toolkit::Button *)jarg1;
69974   {
69975     try {
69976       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
69977     } catch (std::out_of_range& e) {
69978       {
69979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69980       };
69981     } catch (std::exception& e) {
69982       {
69983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69984       };
69985     } catch (Dali::DaliException e) {
69986       {
69987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69988       };
69989     } catch (...) {
69990       {
69991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69992       };
69993     }
69994   }
69995
69996   jresult = new Dali::Actor((const Dali::Actor &)result);
69997   return jresult;
69998 }
69999
70000
70001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
70002   void * jresult ;
70003   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70004   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70005
70006   arg1 = (Dali::Toolkit::Button *)jarg1;
70007   {
70008     try {
70009       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
70010     } catch (std::out_of_range& e) {
70011       {
70012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70013       };
70014     } catch (std::exception& e) {
70015       {
70016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70017       };
70018     } catch (Dali::DaliException e) {
70019       {
70020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70021       };
70022     } catch (...) {
70023       {
70024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70025       };
70026     }
70027   }
70028
70029   jresult = (void *)result;
70030   return jresult;
70031 }
70032
70033
70034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
70035   void * jresult ;
70036   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70037   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70038
70039   arg1 = (Dali::Toolkit::Button *)jarg1;
70040   {
70041     try {
70042       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
70043     } catch (std::out_of_range& e) {
70044       {
70045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70046       };
70047     } catch (std::exception& e) {
70048       {
70049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70050       };
70051     } catch (Dali::DaliException e) {
70052       {
70053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70054       };
70055     } catch (...) {
70056       {
70057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70058       };
70059     }
70060   }
70061
70062   jresult = (void *)result;
70063   return jresult;
70064 }
70065
70066
70067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
70068   void * jresult ;
70069   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70070   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70071
70072   arg1 = (Dali::Toolkit::Button *)jarg1;
70073   {
70074     try {
70075       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
70076     } catch (std::out_of_range& e) {
70077       {
70078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70079       };
70080     } catch (std::exception& e) {
70081       {
70082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70083       };
70084     } catch (Dali::DaliException e) {
70085       {
70086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70087       };
70088     } catch (...) {
70089       {
70090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70091       };
70092     }
70093   }
70094
70095   jresult = (void *)result;
70096   return jresult;
70097 }
70098
70099
70100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
70101   void * jresult ;
70102   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70103   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70104
70105   arg1 = (Dali::Toolkit::Button *)jarg1;
70106   {
70107     try {
70108       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
70109     } catch (std::out_of_range& e) {
70110       {
70111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70112       };
70113     } catch (std::exception& e) {
70114       {
70115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70116       };
70117     } catch (Dali::DaliException e) {
70118       {
70119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70120       };
70121     } catch (...) {
70122       {
70123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70124       };
70125     }
70126   }
70127
70128   jresult = (void *)result;
70129   return jresult;
70130 }
70131
70132
70133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
70134   void * jresult ;
70135   Dali::Toolkit::CheckBoxButton *result = 0 ;
70136
70137   {
70138     try {
70139       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
70140     } catch (std::out_of_range& e) {
70141       {
70142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70143       };
70144     } catch (std::exception& e) {
70145       {
70146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70147       };
70148     } catch (Dali::DaliException e) {
70149       {
70150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70151       };
70152     } catch (...) {
70153       {
70154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70155       };
70156     }
70157   }
70158
70159   jresult = (void *)result;
70160   return jresult;
70161 }
70162
70163
70164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
70165   void * jresult ;
70166   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
70167   Dali::Toolkit::CheckBoxButton *result = 0 ;
70168
70169   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70170   if (!arg1) {
70171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70172     return 0;
70173   }
70174   {
70175     try {
70176       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
70177     } catch (std::out_of_range& e) {
70178       {
70179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70180       };
70181     } catch (std::exception& e) {
70182       {
70183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70184       };
70185     } catch (Dali::DaliException e) {
70186       {
70187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70188       };
70189     } catch (...) {
70190       {
70191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70192       };
70193     }
70194   }
70195
70196   jresult = (void *)result;
70197   return jresult;
70198 }
70199
70200
70201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
70202   void * jresult ;
70203   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70204   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
70205   Dali::Toolkit::CheckBoxButton *result = 0 ;
70206
70207   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70208   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
70209   if (!arg2) {
70210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70211     return 0;
70212   }
70213   {
70214     try {
70215       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
70216     } catch (std::out_of_range& e) {
70217       {
70218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70219       };
70220     } catch (std::exception& e) {
70221       {
70222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70223       };
70224     } catch (Dali::DaliException e) {
70225       {
70226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70227       };
70228     } catch (...) {
70229       {
70230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70231       };
70232     }
70233   }
70234
70235   jresult = (void *)result;
70236   return jresult;
70237 }
70238
70239
70240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
70241   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70242
70243   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70244   {
70245     try {
70246       delete arg1;
70247     } catch (std::out_of_range& e) {
70248       {
70249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70250       };
70251     } catch (std::exception& e) {
70252       {
70253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70254       };
70255     } catch (Dali::DaliException e) {
70256       {
70257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70258       };
70259     } catch (...) {
70260       {
70261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70262       };
70263     }
70264   }
70265
70266 }
70267
70268
70269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
70270   void * jresult ;
70271   Dali::Toolkit::CheckBoxButton result;
70272
70273   {
70274     try {
70275       result = Dali::Toolkit::CheckBoxButton::New();
70276     } catch (std::out_of_range& e) {
70277       {
70278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70279       };
70280     } catch (std::exception& e) {
70281       {
70282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70283       };
70284     } catch (Dali::DaliException e) {
70285       {
70286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70287       };
70288     } catch (...) {
70289       {
70290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70291       };
70292     }
70293   }
70294
70295   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70296   return jresult;
70297 }
70298
70299
70300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
70301   void * jresult ;
70302   Dali::BaseHandle arg1 ;
70303   Dali::BaseHandle *argp1 ;
70304   Dali::Toolkit::CheckBoxButton result;
70305
70306   argp1 = (Dali::BaseHandle *)jarg1;
70307   if (!argp1) {
70308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70309     return 0;
70310   }
70311   arg1 = *argp1;
70312   {
70313     try {
70314       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
70315     } catch (std::out_of_range& e) {
70316       {
70317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70318       };
70319     } catch (std::exception& e) {
70320       {
70321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70322       };
70323     } catch (Dali::DaliException e) {
70324       {
70325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70326       };
70327     } catch (...) {
70328       {
70329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70330       };
70331     }
70332   }
70333
70334   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70335   return jresult;
70336 }
70337
70338
70339 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
70340   int jresult ;
70341   int result;
70342
70343   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
70344   jresult = (int)result;
70345   return jresult;
70346 }
70347
70348
70349 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
70350   int jresult ;
70351   int result;
70352
70353   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
70354   jresult = (int)result;
70355   return jresult;
70356 }
70357
70358
70359 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
70360   int jresult ;
70361   int result;
70362
70363   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
70364   jresult = (int)result;
70365   return jresult;
70366 }
70367
70368
70369 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
70370   int jresult ;
70371   int result;
70372
70373   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
70374   jresult = (int)result;
70375   return jresult;
70376 }
70377
70378
70379 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
70380   int jresult ;
70381   int result;
70382
70383   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
70384   jresult = (int)result;
70385   return jresult;
70386 }
70387
70388
70389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
70390   void * jresult ;
70391   Dali::Toolkit::PushButton::Property *result = 0 ;
70392
70393   {
70394     try {
70395       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
70396     } catch (std::out_of_range& e) {
70397       {
70398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70399       };
70400     } catch (std::exception& e) {
70401       {
70402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70403       };
70404     } catch (Dali::DaliException e) {
70405       {
70406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70407       };
70408     } catch (...) {
70409       {
70410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70411       };
70412     }
70413   }
70414
70415   jresult = (void *)result;
70416   return jresult;
70417 }
70418
70419
70420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
70421   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
70422
70423   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
70424   {
70425     try {
70426       delete arg1;
70427     } catch (std::out_of_range& e) {
70428       {
70429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70430       };
70431     } catch (std::exception& e) {
70432       {
70433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70434       };
70435     } catch (Dali::DaliException e) {
70436       {
70437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70438       };
70439     } catch (...) {
70440       {
70441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70442       };
70443     }
70444   }
70445
70446 }
70447
70448
70449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
70450   void * jresult ;
70451   Dali::Toolkit::PushButton *result = 0 ;
70452
70453   {
70454     try {
70455       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
70456     } catch (std::out_of_range& e) {
70457       {
70458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70459       };
70460     } catch (std::exception& e) {
70461       {
70462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70463       };
70464     } catch (Dali::DaliException e) {
70465       {
70466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70467       };
70468     } catch (...) {
70469       {
70470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70471       };
70472     }
70473   }
70474
70475   jresult = (void *)result;
70476   return jresult;
70477 }
70478
70479
70480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
70481   void * jresult ;
70482   Dali::Toolkit::PushButton *arg1 = 0 ;
70483   Dali::Toolkit::PushButton *result = 0 ;
70484
70485   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70486   if (!arg1) {
70487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70488     return 0;
70489   }
70490   {
70491     try {
70492       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
70493     } catch (std::out_of_range& e) {
70494       {
70495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70496       };
70497     } catch (std::exception& e) {
70498       {
70499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70500       };
70501     } catch (Dali::DaliException e) {
70502       {
70503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70504       };
70505     } catch (...) {
70506       {
70507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70508       };
70509     }
70510   }
70511
70512   jresult = (void *)result;
70513   return jresult;
70514 }
70515
70516
70517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
70518   void * jresult ;
70519   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70520   Dali::Toolkit::PushButton *arg2 = 0 ;
70521   Dali::Toolkit::PushButton *result = 0 ;
70522
70523   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70524   arg2 = (Dali::Toolkit::PushButton *)jarg2;
70525   if (!arg2) {
70526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70527     return 0;
70528   }
70529   {
70530     try {
70531       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
70532     } catch (std::out_of_range& e) {
70533       {
70534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70535       };
70536     } catch (std::exception& e) {
70537       {
70538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70539       };
70540     } catch (Dali::DaliException e) {
70541       {
70542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70543       };
70544     } catch (...) {
70545       {
70546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70547       };
70548     }
70549   }
70550
70551   jresult = (void *)result;
70552   return jresult;
70553 }
70554
70555
70556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
70557   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70558
70559   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70560   {
70561     try {
70562       delete arg1;
70563     } catch (std::out_of_range& e) {
70564       {
70565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70566       };
70567     } catch (std::exception& e) {
70568       {
70569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70570       };
70571     } catch (Dali::DaliException e) {
70572       {
70573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70574       };
70575     } catch (...) {
70576       {
70577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70578       };
70579     }
70580   }
70581
70582 }
70583
70584
70585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
70586   void * jresult ;
70587   Dali::Toolkit::PushButton result;
70588
70589   {
70590     try {
70591       result = Dali::Toolkit::PushButton::New();
70592     } catch (std::out_of_range& e) {
70593       {
70594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70595       };
70596     } catch (std::exception& e) {
70597       {
70598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70599       };
70600     } catch (Dali::DaliException e) {
70601       {
70602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70603       };
70604     } catch (...) {
70605       {
70606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70607       };
70608     }
70609   }
70610
70611   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
70612   return jresult;
70613 }
70614
70615
70616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
70617   void * jresult ;
70618   Dali::BaseHandle arg1 ;
70619   Dali::BaseHandle *argp1 ;
70620   Dali::Toolkit::PushButton result;
70621
70622   argp1 = (Dali::BaseHandle *)jarg1;
70623   if (!argp1) {
70624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70625     return 0;
70626   }
70627   arg1 = *argp1;
70628   {
70629     try {
70630       result = Dali::Toolkit::PushButton::DownCast(arg1);
70631     } catch (std::out_of_range& e) {
70632       {
70633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70634       };
70635     } catch (std::exception& e) {
70636       {
70637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70638       };
70639     } catch (Dali::DaliException e) {
70640       {
70641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70642       };
70643     } catch (...) {
70644       {
70645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70646       };
70647     }
70648   }
70649
70650   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
70651   return jresult;
70652 }
70653
70654
70655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
70656   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70657   Dali::Image arg2 ;
70658   Dali::Image *argp2 ;
70659
70660   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70661   argp2 = (Dali::Image *)jarg2;
70662   if (!argp2) {
70663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70664     return ;
70665   }
70666   arg2 = *argp2;
70667   {
70668     try {
70669       (arg1)->SetButtonImage(arg2);
70670     } catch (std::out_of_range& e) {
70671       {
70672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70673       };
70674     } catch (std::exception& e) {
70675       {
70676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70677       };
70678     } catch (Dali::DaliException e) {
70679       {
70680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70681       };
70682     } catch (...) {
70683       {
70684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70685       };
70686     }
70687   }
70688
70689 }
70690
70691
70692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
70693   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70694   Dali::Actor arg2 ;
70695   Dali::Actor *argp2 ;
70696
70697   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70698   argp2 = (Dali::Actor *)jarg2;
70699   if (!argp2) {
70700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70701     return ;
70702   }
70703   arg2 = *argp2;
70704   {
70705     try {
70706       (arg1)->SetButtonImage(arg2);
70707     } catch (std::out_of_range& e) {
70708       {
70709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70710       };
70711     } catch (std::exception& e) {
70712       {
70713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70714       };
70715     } catch (Dali::DaliException e) {
70716       {
70717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70718       };
70719     } catch (...) {
70720       {
70721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70722       };
70723     }
70724   }
70725
70726 }
70727
70728
70729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
70730   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70731   Dali::Actor arg2 ;
70732   Dali::Actor *argp2 ;
70733
70734   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70735   argp2 = (Dali::Actor *)jarg2;
70736   if (!argp2) {
70737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70738     return ;
70739   }
70740   arg2 = *argp2;
70741   {
70742     try {
70743       (arg1)->SetBackgroundImage(arg2);
70744     } catch (std::out_of_range& e) {
70745       {
70746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70747       };
70748     } catch (std::exception& e) {
70749       {
70750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70751       };
70752     } catch (Dali::DaliException e) {
70753       {
70754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70755       };
70756     } catch (...) {
70757       {
70758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70759       };
70760     }
70761   }
70762
70763 }
70764
70765
70766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
70767   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70768   Dali::Image arg2 ;
70769   Dali::Image *argp2 ;
70770
70771   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70772   argp2 = (Dali::Image *)jarg2;
70773   if (!argp2) {
70774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70775     return ;
70776   }
70777   arg2 = *argp2;
70778   {
70779     try {
70780       (arg1)->SetSelectedImage(arg2);
70781     } catch (std::out_of_range& e) {
70782       {
70783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70784       };
70785     } catch (std::exception& e) {
70786       {
70787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70788       };
70789     } catch (Dali::DaliException e) {
70790       {
70791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70792       };
70793     } catch (...) {
70794       {
70795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70796       };
70797     }
70798   }
70799
70800 }
70801
70802
70803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
70804   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70805   Dali::Actor arg2 ;
70806   Dali::Actor *argp2 ;
70807
70808   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70809   argp2 = (Dali::Actor *)jarg2;
70810   if (!argp2) {
70811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70812     return ;
70813   }
70814   arg2 = *argp2;
70815   {
70816     try {
70817       (arg1)->SetSelectedImage(arg2);
70818     } catch (std::out_of_range& e) {
70819       {
70820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70821       };
70822     } catch (std::exception& e) {
70823       {
70824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70825       };
70826     } catch (Dali::DaliException e) {
70827       {
70828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70829       };
70830     } catch (...) {
70831       {
70832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70833       };
70834     }
70835   }
70836
70837 }
70838
70839
70840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
70841   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70842   Dali::Actor arg2 ;
70843   Dali::Actor *argp2 ;
70844
70845   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70846   argp2 = (Dali::Actor *)jarg2;
70847   if (!argp2) {
70848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70849     return ;
70850   }
70851   arg2 = *argp2;
70852   {
70853     try {
70854       (arg1)->SetSelectedBackgroundImage(arg2);
70855     } catch (std::out_of_range& e) {
70856       {
70857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70858       };
70859     } catch (std::exception& e) {
70860       {
70861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70862       };
70863     } catch (Dali::DaliException e) {
70864       {
70865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70866       };
70867     } catch (...) {
70868       {
70869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70870       };
70871     }
70872   }
70873
70874 }
70875
70876
70877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
70878   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70879   Dali::Actor arg2 ;
70880   Dali::Actor *argp2 ;
70881
70882   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70883   argp2 = (Dali::Actor *)jarg2;
70884   if (!argp2) {
70885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70886     return ;
70887   }
70888   arg2 = *argp2;
70889   {
70890     try {
70891       (arg1)->SetDisabledBackgroundImage(arg2);
70892     } catch (std::out_of_range& e) {
70893       {
70894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70895       };
70896     } catch (std::exception& e) {
70897       {
70898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70899       };
70900     } catch (Dali::DaliException e) {
70901       {
70902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70903       };
70904     } catch (...) {
70905       {
70906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70907       };
70908     }
70909   }
70910
70911 }
70912
70913
70914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
70915   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70916   Dali::Actor arg2 ;
70917   Dali::Actor *argp2 ;
70918
70919   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70920   argp2 = (Dali::Actor *)jarg2;
70921   if (!argp2) {
70922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70923     return ;
70924   }
70925   arg2 = *argp2;
70926   {
70927     try {
70928       (arg1)->SetDisabledImage(arg2);
70929     } catch (std::out_of_range& e) {
70930       {
70931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70932       };
70933     } catch (std::exception& e) {
70934       {
70935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70936       };
70937     } catch (Dali::DaliException e) {
70938       {
70939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70940       };
70941     } catch (...) {
70942       {
70943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70944       };
70945     }
70946   }
70947
70948 }
70949
70950
70951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
70952   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70953   Dali::Actor arg2 ;
70954   Dali::Actor *argp2 ;
70955
70956   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70957   argp2 = (Dali::Actor *)jarg2;
70958   if (!argp2) {
70959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70960     return ;
70961   }
70962   arg2 = *argp2;
70963   {
70964     try {
70965       (arg1)->SetDisabledSelectedImage(arg2);
70966     } catch (std::out_of_range& e) {
70967       {
70968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70969       };
70970     } catch (std::exception& e) {
70971       {
70972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70973       };
70974     } catch (Dali::DaliException e) {
70975       {
70976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70977       };
70978     } catch (...) {
70979       {
70980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70981       };
70982     }
70983   }
70984
70985 }
70986
70987
70988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
70989   void * jresult ;
70990   Dali::Toolkit::RadioButton *result = 0 ;
70991
70992   {
70993     try {
70994       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
70995     } catch (std::out_of_range& e) {
70996       {
70997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70998       };
70999     } catch (std::exception& e) {
71000       {
71001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71002       };
71003     } catch (Dali::DaliException e) {
71004       {
71005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71006       };
71007     } catch (...) {
71008       {
71009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71010       };
71011     }
71012   }
71013
71014   jresult = (void *)result;
71015   return jresult;
71016 }
71017
71018
71019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
71020   void * jresult ;
71021   Dali::Toolkit::RadioButton *arg1 = 0 ;
71022   Dali::Toolkit::RadioButton *result = 0 ;
71023
71024   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71025   if (!arg1) {
71026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
71027     return 0;
71028   }
71029   {
71030     try {
71031       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
71032     } catch (std::out_of_range& e) {
71033       {
71034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71035       };
71036     } catch (std::exception& e) {
71037       {
71038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71039       };
71040     } catch (Dali::DaliException e) {
71041       {
71042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71043       };
71044     } catch (...) {
71045       {
71046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71047       };
71048     }
71049   }
71050
71051   jresult = (void *)result;
71052   return jresult;
71053 }
71054
71055
71056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
71057   void * jresult ;
71058   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
71059   Dali::Toolkit::RadioButton *arg2 = 0 ;
71060   Dali::Toolkit::RadioButton *result = 0 ;
71061
71062   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71063   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
71064   if (!arg2) {
71065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
71066     return 0;
71067   }
71068   {
71069     try {
71070       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
71071     } catch (std::out_of_range& e) {
71072       {
71073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71074       };
71075     } catch (std::exception& e) {
71076       {
71077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71078       };
71079     } catch (Dali::DaliException e) {
71080       {
71081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71082       };
71083     } catch (...) {
71084       {
71085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71086       };
71087     }
71088   }
71089
71090   jresult = (void *)result;
71091   return jresult;
71092 }
71093
71094
71095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
71096   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
71097
71098   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71099   {
71100     try {
71101       delete arg1;
71102     } catch (std::out_of_range& e) {
71103       {
71104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71105       };
71106     } catch (std::exception& e) {
71107       {
71108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71109       };
71110     } catch (Dali::DaliException e) {
71111       {
71112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71113       };
71114     } catch (...) {
71115       {
71116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71117       };
71118     }
71119   }
71120
71121 }
71122
71123
71124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
71125   void * jresult ;
71126   Dali::Toolkit::RadioButton result;
71127
71128   {
71129     try {
71130       result = Dali::Toolkit::RadioButton::New();
71131     } catch (std::out_of_range& e) {
71132       {
71133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71134       };
71135     } catch (std::exception& e) {
71136       {
71137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71138       };
71139     } catch (Dali::DaliException e) {
71140       {
71141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71142       };
71143     } catch (...) {
71144       {
71145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71146       };
71147     }
71148   }
71149
71150   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71151   return jresult;
71152 }
71153
71154
71155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
71156   void * jresult ;
71157   std::string *arg1 = 0 ;
71158   Dali::Toolkit::RadioButton result;
71159
71160   if (!jarg1) {
71161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71162     return 0;
71163   }
71164   std::string arg1_str(jarg1);
71165   arg1 = &arg1_str;
71166   {
71167     try {
71168       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
71169     } catch (std::out_of_range& e) {
71170       {
71171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71172       };
71173     } catch (std::exception& e) {
71174       {
71175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71176       };
71177     } catch (Dali::DaliException e) {
71178       {
71179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71180       };
71181     } catch (...) {
71182       {
71183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71184       };
71185     }
71186   }
71187
71188   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71189
71190   //argout typemap for const std::string&
71191
71192   return jresult;
71193 }
71194
71195
71196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
71197   void * jresult ;
71198   Dali::BaseHandle arg1 ;
71199   Dali::BaseHandle *argp1 ;
71200   Dali::Toolkit::RadioButton result;
71201
71202   argp1 = (Dali::BaseHandle *)jarg1;
71203   if (!argp1) {
71204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71205     return 0;
71206   }
71207   arg1 = *argp1;
71208   {
71209     try {
71210       result = Dali::Toolkit::RadioButton::DownCast(arg1);
71211     } catch (std::out_of_range& e) {
71212       {
71213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71214       };
71215     } catch (std::exception& e) {
71216       {
71217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71218       };
71219     } catch (Dali::DaliException e) {
71220       {
71221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71222       };
71223     } catch (...) {
71224       {
71225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71226       };
71227     }
71228   }
71229
71230   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71231   return jresult;
71232 }
71233
71234
71235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
71236   int jresult ;
71237   int result;
71238
71239   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
71240   jresult = (int)result;
71241   return jresult;
71242 }
71243
71244
71245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
71246   int jresult ;
71247   int result;
71248
71249   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
71250   jresult = (int)result;
71251   return jresult;
71252 }
71253
71254
71255 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
71256   int jresult ;
71257   int result;
71258
71259   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
71260   jresult = (int)result;
71261   return jresult;
71262 }
71263
71264
71265 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
71266   int jresult ;
71267   int result;
71268
71269   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
71270   jresult = (int)result;
71271   return jresult;
71272 }
71273
71274
71275 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
71276   int jresult ;
71277   int result;
71278
71279   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
71280   jresult = (int)result;
71281   return jresult;
71282 }
71283
71284
71285 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
71286   int jresult ;
71287   int result;
71288
71289   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
71290   jresult = (int)result;
71291   return jresult;
71292 }
71293
71294
71295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
71296   void * jresult ;
71297   Dali::Toolkit::FlexContainer::Property *result = 0 ;
71298
71299   {
71300     try {
71301       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
71302     } catch (std::out_of_range& e) {
71303       {
71304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71305       };
71306     } catch (std::exception& e) {
71307       {
71308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71309       };
71310     } catch (Dali::DaliException e) {
71311       {
71312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71313       };
71314     } catch (...) {
71315       {
71316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71317       };
71318     }
71319   }
71320
71321   jresult = (void *)result;
71322   return jresult;
71323 }
71324
71325
71326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
71327   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
71328
71329   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
71330   {
71331     try {
71332       delete arg1;
71333     } catch (std::out_of_range& e) {
71334       {
71335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71336       };
71337     } catch (std::exception& e) {
71338       {
71339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71340       };
71341     } catch (Dali::DaliException e) {
71342       {
71343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71344       };
71345     } catch (...) {
71346       {
71347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71348       };
71349     }
71350   }
71351
71352 }
71353
71354
71355 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
71356   int jresult ;
71357   int result;
71358
71359   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
71360   jresult = (int)result;
71361   return jresult;
71362 }
71363
71364
71365 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
71366   int jresult ;
71367   int result;
71368
71369   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
71370   jresult = (int)result;
71371   return jresult;
71372 }
71373
71374
71375 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
71376   int jresult ;
71377   int result;
71378
71379   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
71380   jresult = (int)result;
71381   return jresult;
71382 }
71383
71384
71385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
71386   void * jresult ;
71387   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
71388
71389   {
71390     try {
71391       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
71392     } catch (std::out_of_range& e) {
71393       {
71394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71395       };
71396     } catch (std::exception& e) {
71397       {
71398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71399       };
71400     } catch (Dali::DaliException e) {
71401       {
71402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71403       };
71404     } catch (...) {
71405       {
71406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71407       };
71408     }
71409   }
71410
71411   jresult = (void *)result;
71412   return jresult;
71413 }
71414
71415
71416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
71417   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
71418
71419   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
71420   {
71421     try {
71422       delete arg1;
71423     } catch (std::out_of_range& e) {
71424       {
71425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71426       };
71427     } catch (std::exception& e) {
71428       {
71429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71430       };
71431     } catch (Dali::DaliException e) {
71432       {
71433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71434       };
71435     } catch (...) {
71436       {
71437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71438       };
71439     }
71440   }
71441
71442 }
71443
71444
71445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
71446   void * jresult ;
71447   Dali::Toolkit::FlexContainer *result = 0 ;
71448
71449   {
71450     try {
71451       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
71452     } catch (std::out_of_range& e) {
71453       {
71454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71455       };
71456     } catch (std::exception& e) {
71457       {
71458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71459       };
71460     } catch (Dali::DaliException e) {
71461       {
71462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71463       };
71464     } catch (...) {
71465       {
71466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71467       };
71468     }
71469   }
71470
71471   jresult = (void *)result;
71472   return jresult;
71473 }
71474
71475
71476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
71477   void * jresult ;
71478   Dali::Toolkit::FlexContainer *arg1 = 0 ;
71479   Dali::Toolkit::FlexContainer *result = 0 ;
71480
71481   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71482   if (!arg1) {
71483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71484     return 0;
71485   }
71486   {
71487     try {
71488       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
71489     } catch (std::out_of_range& e) {
71490       {
71491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71492       };
71493     } catch (std::exception& e) {
71494       {
71495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71496       };
71497     } catch (Dali::DaliException e) {
71498       {
71499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71500       };
71501     } catch (...) {
71502       {
71503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71504       };
71505     }
71506   }
71507
71508   jresult = (void *)result;
71509   return jresult;
71510 }
71511
71512
71513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
71514   void * jresult ;
71515   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71516   Dali::Toolkit::FlexContainer *arg2 = 0 ;
71517   Dali::Toolkit::FlexContainer *result = 0 ;
71518
71519   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71520   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
71521   if (!arg2) {
71522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71523     return 0;
71524   }
71525   {
71526     try {
71527       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
71528     } catch (std::out_of_range& e) {
71529       {
71530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71531       };
71532     } catch (std::exception& e) {
71533       {
71534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71535       };
71536     } catch (Dali::DaliException e) {
71537       {
71538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71539       };
71540     } catch (...) {
71541       {
71542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71543       };
71544     }
71545   }
71546
71547   jresult = (void *)result;
71548   return jresult;
71549 }
71550
71551
71552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
71553   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71554
71555   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71556   {
71557     try {
71558       delete arg1;
71559     } catch (std::out_of_range& e) {
71560       {
71561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71562       };
71563     } catch (std::exception& e) {
71564       {
71565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71566       };
71567     } catch (Dali::DaliException e) {
71568       {
71569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71570       };
71571     } catch (...) {
71572       {
71573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71574       };
71575     }
71576   }
71577
71578 }
71579
71580
71581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
71582   void * jresult ;
71583   Dali::Toolkit::FlexContainer result;
71584
71585   {
71586     try {
71587       result = Dali::Toolkit::FlexContainer::New();
71588     } catch (std::out_of_range& e) {
71589       {
71590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71591       };
71592     } catch (std::exception& e) {
71593       {
71594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71595       };
71596     } catch (Dali::DaliException e) {
71597       {
71598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71599       };
71600     } catch (...) {
71601       {
71602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71603       };
71604     }
71605   }
71606
71607   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
71608   return jresult;
71609 }
71610
71611
71612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
71613   void * jresult ;
71614   Dali::BaseHandle arg1 ;
71615   Dali::BaseHandle *argp1 ;
71616   Dali::Toolkit::FlexContainer result;
71617
71618   argp1 = (Dali::BaseHandle *)jarg1;
71619   if (!argp1) {
71620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71621     return 0;
71622   }
71623   arg1 = *argp1;
71624   {
71625     try {
71626       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
71627     } catch (std::out_of_range& e) {
71628       {
71629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71630       };
71631     } catch (std::exception& e) {
71632       {
71633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71634       };
71635     } catch (Dali::DaliException e) {
71636       {
71637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71638       };
71639     } catch (...) {
71640       {
71641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71642       };
71643     }
71644   }
71645
71646   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
71647   return jresult;
71648 }
71649
71650
71651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
71652   int jresult ;
71653   int result;
71654
71655   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
71656   jresult = (int)result;
71657   return jresult;
71658 }
71659
71660
71661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
71662   int jresult ;
71663   int result;
71664
71665   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
71666   jresult = (int)result;
71667   return jresult;
71668 }
71669
71670
71671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
71672   int jresult ;
71673   int result;
71674
71675   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
71676   jresult = (int)result;
71677   return jresult;
71678 }
71679
71680
71681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
71682   int jresult ;
71683   int result;
71684
71685   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
71686   jresult = (int)result;
71687   return jresult;
71688 }
71689
71690
71691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
71692   void * jresult ;
71693   Dali::Toolkit::ImageView::Property *result = 0 ;
71694
71695   {
71696     try {
71697       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
71698     } catch (std::out_of_range& e) {
71699       {
71700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71701       };
71702     } catch (std::exception& e) {
71703       {
71704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71705       };
71706     } catch (Dali::DaliException e) {
71707       {
71708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71709       };
71710     } catch (...) {
71711       {
71712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71713       };
71714     }
71715   }
71716
71717   jresult = (void *)result;
71718   return jresult;
71719 }
71720
71721
71722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
71723   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
71724
71725   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
71726   {
71727     try {
71728       delete arg1;
71729     } catch (std::out_of_range& e) {
71730       {
71731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71732       };
71733     } catch (std::exception& e) {
71734       {
71735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71736       };
71737     } catch (Dali::DaliException e) {
71738       {
71739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71740       };
71741     } catch (...) {
71742       {
71743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71744       };
71745     }
71746   }
71747
71748 }
71749
71750
71751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
71752   void * jresult ;
71753   Dali::Toolkit::ImageView *result = 0 ;
71754
71755   {
71756     try {
71757       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
71758     } catch (std::out_of_range& e) {
71759       {
71760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71761       };
71762     } catch (std::exception& e) {
71763       {
71764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71765       };
71766     } catch (Dali::DaliException e) {
71767       {
71768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71769       };
71770     } catch (...) {
71771       {
71772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71773       };
71774     }
71775   }
71776
71777   jresult = (void *)result;
71778   return jresult;
71779 }
71780
71781
71782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
71783   void * jresult ;
71784   Dali::Toolkit::ImageView result;
71785
71786   {
71787     try {
71788       result = Dali::Toolkit::ImageView::New();
71789     } catch (std::out_of_range& e) {
71790       {
71791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71792       };
71793     } catch (std::exception& e) {
71794       {
71795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71796       };
71797     } catch (Dali::DaliException e) {
71798       {
71799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71800       };
71801     } catch (...) {
71802       {
71803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71804       };
71805     }
71806   }
71807
71808   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71809   return jresult;
71810 }
71811
71812
71813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
71814   void * jresult ;
71815   Dali::Image arg1 ;
71816   Dali::Image *argp1 ;
71817   Dali::Toolkit::ImageView result;
71818
71819   argp1 = (Dali::Image *)jarg1;
71820   if (!argp1) {
71821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71822     return 0;
71823   }
71824   arg1 = *argp1;
71825   {
71826     try {
71827       result = Dali::Toolkit::ImageView::New(arg1);
71828     } catch (std::out_of_range& e) {
71829       {
71830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71831       };
71832     } catch (std::exception& e) {
71833       {
71834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71835       };
71836     } catch (Dali::DaliException e) {
71837       {
71838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71839       };
71840     } catch (...) {
71841       {
71842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71843       };
71844     }
71845   }
71846
71847   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71848   return jresult;
71849 }
71850
71851
71852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
71853   void * jresult ;
71854   std::string *arg1 = 0 ;
71855   Dali::Toolkit::ImageView result;
71856
71857   if (!jarg1) {
71858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71859     return 0;
71860   }
71861   std::string arg1_str(jarg1);
71862   arg1 = &arg1_str;
71863   {
71864     try {
71865       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
71866     } catch (std::out_of_range& e) {
71867       {
71868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71869       };
71870     } catch (std::exception& e) {
71871       {
71872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71873       };
71874     } catch (Dali::DaliException e) {
71875       {
71876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71877       };
71878     } catch (...) {
71879       {
71880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71881       };
71882     }
71883   }
71884
71885   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71886
71887   //argout typemap for const std::string&
71888
71889   return jresult;
71890 }
71891
71892
71893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
71894   void * jresult ;
71895   std::string *arg1 = 0 ;
71896   Dali::ImageDimensions arg2 ;
71897   Dali::ImageDimensions *argp2 ;
71898   Dali::Toolkit::ImageView result;
71899
71900   if (!jarg1) {
71901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71902     return 0;
71903   }
71904   std::string arg1_str(jarg1);
71905   arg1 = &arg1_str;
71906   argp2 = (Dali::ImageDimensions *)jarg2;
71907   if (!argp2) {
71908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
71909     return 0;
71910   }
71911   arg2 = *argp2;
71912   {
71913     try {
71914       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
71915     } catch (std::out_of_range& e) {
71916       {
71917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71918       };
71919     } catch (std::exception& e) {
71920       {
71921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71922       };
71923     } catch (Dali::DaliException e) {
71924       {
71925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71926       };
71927     } catch (...) {
71928       {
71929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71930       };
71931     }
71932   }
71933
71934   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71935
71936   //argout typemap for const std::string&
71937
71938   return jresult;
71939 }
71940
71941
71942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
71943   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71944
71945   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71946   {
71947     try {
71948       delete arg1;
71949     } catch (std::out_of_range& e) {
71950       {
71951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71952       };
71953     } catch (std::exception& e) {
71954       {
71955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71956       };
71957     } catch (Dali::DaliException e) {
71958       {
71959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71960       };
71961     } catch (...) {
71962       {
71963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71964       };
71965     }
71966   }
71967
71968 }
71969
71970
71971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
71972   void * jresult ;
71973   Dali::Toolkit::ImageView *arg1 = 0 ;
71974   Dali::Toolkit::ImageView *result = 0 ;
71975
71976   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71977   if (!arg1) {
71978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
71979     return 0;
71980   }
71981   {
71982     try {
71983       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
71984     } catch (std::out_of_range& e) {
71985       {
71986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71987       };
71988     } catch (std::exception& e) {
71989       {
71990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71991       };
71992     } catch (Dali::DaliException e) {
71993       {
71994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71995       };
71996     } catch (...) {
71997       {
71998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71999       };
72000     }
72001   }
72002
72003   jresult = (void *)result;
72004   return jresult;
72005 }
72006
72007
72008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
72009   void * jresult ;
72010   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72011   Dali::Toolkit::ImageView *arg2 = 0 ;
72012   Dali::Toolkit::ImageView *result = 0 ;
72013
72014   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72015   arg2 = (Dali::Toolkit::ImageView *)jarg2;
72016   if (!arg2) {
72017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
72018     return 0;
72019   }
72020   {
72021     try {
72022       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
72023     } catch (std::out_of_range& e) {
72024       {
72025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72026       };
72027     } catch (std::exception& e) {
72028       {
72029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72030       };
72031     } catch (Dali::DaliException e) {
72032       {
72033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72034       };
72035     } catch (...) {
72036       {
72037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72038       };
72039     }
72040   }
72041
72042   jresult = (void *)result;
72043   return jresult;
72044 }
72045
72046
72047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
72048   void * jresult ;
72049   Dali::BaseHandle arg1 ;
72050   Dali::BaseHandle *argp1 ;
72051   Dali::Toolkit::ImageView result;
72052
72053   argp1 = (Dali::BaseHandle *)jarg1;
72054   if (!argp1) {
72055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72056     return 0;
72057   }
72058   arg1 = *argp1;
72059   {
72060     try {
72061       result = Dali::Toolkit::ImageView::DownCast(arg1);
72062     } catch (std::out_of_range& e) {
72063       {
72064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72065       };
72066     } catch (std::exception& e) {
72067       {
72068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72069       };
72070     } catch (Dali::DaliException e) {
72071       {
72072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72073       };
72074     } catch (...) {
72075       {
72076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72077       };
72078     }
72079   }
72080
72081   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72082   return jresult;
72083 }
72084
72085
72086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
72087   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72088   Dali::Image arg2 ;
72089   Dali::Image *argp2 ;
72090
72091   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72092   argp2 = (Dali::Image *)jarg2;
72093   if (!argp2) {
72094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
72095     return ;
72096   }
72097   arg2 = *argp2;
72098   {
72099     try {
72100       (arg1)->SetImage(arg2);
72101     } catch (std::out_of_range& e) {
72102       {
72103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72104       };
72105     } catch (std::exception& e) {
72106       {
72107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72108       };
72109     } catch (Dali::DaliException e) {
72110       {
72111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72112       };
72113     } catch (...) {
72114       {
72115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72116       };
72117     }
72118   }
72119
72120 }
72121
72122
72123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
72124   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72125   std::string *arg2 = 0 ;
72126
72127   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72128   if (!jarg2) {
72129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72130     return ;
72131   }
72132   std::string arg2_str(jarg2);
72133   arg2 = &arg2_str;
72134   {
72135     try {
72136       (arg1)->SetImage((std::string const &)*arg2);
72137     } catch (std::out_of_range& e) {
72138       {
72139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72140       };
72141     } catch (std::exception& e) {
72142       {
72143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72144       };
72145     } catch (Dali::DaliException e) {
72146       {
72147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72148       };
72149     } catch (...) {
72150       {
72151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72152       };
72153     }
72154   }
72155
72156
72157   //argout typemap for const std::string&
72158
72159 }
72160
72161
72162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
72163   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72164   std::string *arg2 = 0 ;
72165   Dali::ImageDimensions arg3 ;
72166   Dali::ImageDimensions *argp3 ;
72167
72168   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72169   if (!jarg2) {
72170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72171     return ;
72172   }
72173   std::string arg2_str(jarg2);
72174   arg2 = &arg2_str;
72175   argp3 = (Dali::ImageDimensions *)jarg3;
72176   if (!argp3) {
72177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
72178     return ;
72179   }
72180   arg3 = *argp3;
72181   {
72182     try {
72183       (arg1)->SetImage((std::string const &)*arg2,arg3);
72184     } catch (std::out_of_range& e) {
72185       {
72186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72187       };
72188     } catch (std::exception& e) {
72189       {
72190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72191       };
72192     } catch (Dali::DaliException e) {
72193       {
72194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72195       };
72196     } catch (...) {
72197       {
72198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72199       };
72200     }
72201   }
72202
72203
72204   //argout typemap for const std::string&
72205
72206 }
72207
72208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
72209   void * jresult ;
72210   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72211   Dali::Image result;
72212
72213   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72214   {
72215     try {
72216       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
72217     } catch (std::out_of_range& e) {
72218       {
72219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72220       };
72221     } catch (std::exception& e) {
72222       {
72223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72224       };
72225     } catch (Dali::DaliException e) {
72226       {
72227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72228       };
72229     } catch (...) {
72230       {
72231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72232       };
72233     }
72234   }
72235
72236   jresult = new Dali::Image((const Dali::Image &)result);
72237   return jresult;
72238 }
72239
72240
72241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
72242   int jresult ;
72243   int result;
72244
72245   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
72246   jresult = (int)result;
72247   return jresult;
72248 }
72249
72250
72251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
72252   int jresult ;
72253   int result;
72254
72255   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
72256   jresult = (int)result;
72257   return jresult;
72258 }
72259
72260
72261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
72262   int jresult ;
72263   int result;
72264
72265   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
72266   jresult = (int)result;
72267   return jresult;
72268 }
72269
72270
72271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
72272   int jresult ;
72273   int result;
72274
72275   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
72276   jresult = (int)result;
72277   return jresult;
72278 }
72279
72280
72281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
72282   int jresult ;
72283   int result;
72284
72285   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
72286   jresult = (int)result;
72287   return jresult;
72288 }
72289
72290
72291 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
72292   int jresult ;
72293   int result;
72294
72295   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
72296   jresult = (int)result;
72297   return jresult;
72298 }
72299
72300
72301 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
72302   int jresult ;
72303   int result;
72304
72305   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
72306   jresult = (int)result;
72307   return jresult;
72308 }
72309
72310
72311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
72312   int jresult ;
72313   int result;
72314
72315   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
72316   jresult = (int)result;
72317   return jresult;
72318 }
72319
72320
72321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
72322   void * jresult ;
72323   Dali::Toolkit::Model3dView::Property *result = 0 ;
72324
72325   {
72326     try {
72327       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
72328     } catch (std::out_of_range& e) {
72329       {
72330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72331       };
72332     } catch (std::exception& e) {
72333       {
72334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72335       };
72336     } catch (Dali::DaliException e) {
72337       {
72338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72339       };
72340     } catch (...) {
72341       {
72342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72343       };
72344     }
72345   }
72346
72347   jresult = (void *)result;
72348   return jresult;
72349 }
72350
72351
72352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
72353   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
72354
72355   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
72356   {
72357     try {
72358       delete arg1;
72359     } catch (std::out_of_range& e) {
72360       {
72361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72362       };
72363     } catch (std::exception& e) {
72364       {
72365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72366       };
72367     } catch (Dali::DaliException e) {
72368       {
72369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72370       };
72371     } catch (...) {
72372       {
72373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72374       };
72375     }
72376   }
72377
72378 }
72379
72380
72381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
72382   void * jresult ;
72383   Dali::Toolkit::Model3dView result;
72384
72385   {
72386     try {
72387       result = Dali::Toolkit::Model3dView::New();
72388     } catch (std::out_of_range& e) {
72389       {
72390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72391       };
72392     } catch (std::exception& e) {
72393       {
72394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72395       };
72396     } catch (Dali::DaliException e) {
72397       {
72398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72399       };
72400     } catch (...) {
72401       {
72402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72403       };
72404     }
72405   }
72406
72407   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72408   return jresult;
72409 }
72410
72411
72412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
72413   void * jresult ;
72414   std::string *arg1 = 0 ;
72415   std::string *arg2 = 0 ;
72416   std::string *arg3 = 0 ;
72417   Dali::Toolkit::Model3dView result;
72418
72419   if (!jarg1) {
72420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72421     return 0;
72422   }
72423   std::string arg1_str(jarg1);
72424   arg1 = &arg1_str;
72425   if (!jarg2) {
72426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72427     return 0;
72428   }
72429   std::string arg2_str(jarg2);
72430   arg2 = &arg2_str;
72431   if (!jarg3) {
72432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72433     return 0;
72434   }
72435   std::string arg3_str(jarg3);
72436   arg3 = &arg3_str;
72437   {
72438     try {
72439       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
72440     } catch (std::out_of_range& e) {
72441       {
72442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72443       };
72444     } catch (std::exception& e) {
72445       {
72446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72447       };
72448     } catch (Dali::DaliException e) {
72449       {
72450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72451       };
72452     } catch (...) {
72453       {
72454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72455       };
72456     }
72457   }
72458
72459   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72460
72461   //argout typemap for const std::string&
72462
72463
72464   //argout typemap for const std::string&
72465
72466
72467   //argout typemap for const std::string&
72468
72469   return jresult;
72470 }
72471
72472
72473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
72474   void * jresult ;
72475   Dali::Toolkit::Model3dView *result = 0 ;
72476
72477   {
72478     try {
72479       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
72480     } catch (std::out_of_range& e) {
72481       {
72482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72483       };
72484     } catch (std::exception& e) {
72485       {
72486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72487       };
72488     } catch (Dali::DaliException e) {
72489       {
72490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72491       };
72492     } catch (...) {
72493       {
72494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72495       };
72496     }
72497   }
72498
72499   jresult = (void *)result;
72500   return jresult;
72501 }
72502
72503
72504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
72505   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72506
72507   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72508   {
72509     try {
72510       delete arg1;
72511     } catch (std::out_of_range& e) {
72512       {
72513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72514       };
72515     } catch (std::exception& e) {
72516       {
72517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72518       };
72519     } catch (Dali::DaliException e) {
72520       {
72521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72522       };
72523     } catch (...) {
72524       {
72525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72526       };
72527     }
72528   }
72529
72530 }
72531
72532
72533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
72534   void * jresult ;
72535   Dali::Toolkit::Model3dView *arg1 = 0 ;
72536   Dali::Toolkit::Model3dView *result = 0 ;
72537
72538   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72539   if (!arg1) {
72540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
72541     return 0;
72542   }
72543   {
72544     try {
72545       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
72546     } catch (std::out_of_range& e) {
72547       {
72548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72549       };
72550     } catch (std::exception& e) {
72551       {
72552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72553       };
72554     } catch (Dali::DaliException e) {
72555       {
72556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72557       };
72558     } catch (...) {
72559       {
72560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72561       };
72562     }
72563   }
72564
72565   jresult = (void *)result;
72566   return jresult;
72567 }
72568
72569
72570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
72571   void * jresult ;
72572   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72573   Dali::Toolkit::Model3dView *arg2 = 0 ;
72574   Dali::Toolkit::Model3dView *result = 0 ;
72575
72576   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72577   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
72578   if (!arg2) {
72579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
72580     return 0;
72581   }
72582   {
72583     try {
72584       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
72585     } catch (std::out_of_range& e) {
72586       {
72587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72588       };
72589     } catch (std::exception& e) {
72590       {
72591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72592       };
72593     } catch (Dali::DaliException e) {
72594       {
72595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72596       };
72597     } catch (...) {
72598       {
72599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72600       };
72601     }
72602   }
72603
72604   jresult = (void *)result;
72605   return jresult;
72606 }
72607
72608
72609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
72610   void * jresult ;
72611   Dali::BaseHandle arg1 ;
72612   Dali::BaseHandle *argp1 ;
72613   Dali::Toolkit::Model3dView result;
72614
72615   argp1 = (Dali::BaseHandle *)jarg1;
72616   if (!argp1) {
72617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72618     return 0;
72619   }
72620   arg1 = *argp1;
72621   {
72622     try {
72623       result = Dali::Toolkit::Model3dView::DownCast(arg1);
72624     } catch (std::out_of_range& e) {
72625       {
72626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72627       };
72628     } catch (std::exception& e) {
72629       {
72630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72631       };
72632     } catch (Dali::DaliException e) {
72633       {
72634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72635       };
72636     } catch (...) {
72637       {
72638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72639       };
72640     }
72641   }
72642
72643   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72644   return jresult;
72645 }
72646
72647
72648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
72649   int jresult ;
72650   int result;
72651
72652   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
72653   jresult = (int)result;
72654   return jresult;
72655 }
72656
72657
72658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
72659   int jresult ;
72660   int result;
72661
72662   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
72663   jresult = (int)result;
72664   return jresult;
72665 }
72666
72667
72668 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
72669   int jresult ;
72670   int result;
72671
72672   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
72673   jresult = (int)result;
72674   return jresult;
72675 }
72676
72677
72678 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
72679   int jresult ;
72680   int result;
72681
72682   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
72683   jresult = (int)result;
72684   return jresult;
72685 }
72686
72687
72688 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
72689   int jresult ;
72690   int result;
72691
72692   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
72693   jresult = (int)result;
72694   return jresult;
72695 }
72696
72697
72698 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
72699   int jresult ;
72700   int result;
72701
72702   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
72703   jresult = (int)result;
72704   return jresult;
72705 }
72706
72707
72708 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
72709   int jresult ;
72710   int result;
72711
72712   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
72713   jresult = (int)result;
72714   return jresult;
72715 }
72716
72717
72718 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
72719   int jresult ;
72720   int result;
72721
72722   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
72723   jresult = (int)result;
72724   return jresult;
72725 }
72726
72727
72728 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
72729   int jresult ;
72730   int result;
72731
72732   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
72733   jresult = (int)result;
72734   return jresult;
72735 }
72736
72737
72738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
72739   void * jresult ;
72740   Dali::Toolkit::ScrollBar::Property *result = 0 ;
72741
72742   {
72743     try {
72744       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
72745     } catch (std::out_of_range& e) {
72746       {
72747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72748       };
72749     } catch (std::exception& e) {
72750       {
72751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72752       };
72753     } catch (Dali::DaliException e) {
72754       {
72755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72756       };
72757     } catch (...) {
72758       {
72759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72760       };
72761     }
72762   }
72763
72764   jresult = (void *)result;
72765   return jresult;
72766 }
72767
72768
72769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
72770   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
72771
72772   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
72773   {
72774     try {
72775       delete arg1;
72776     } catch (std::out_of_range& e) {
72777       {
72778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72779       };
72780     } catch (std::exception& e) {
72781       {
72782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72783       };
72784     } catch (Dali::DaliException e) {
72785       {
72786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72787       };
72788     } catch (...) {
72789       {
72790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72791       };
72792     }
72793   }
72794
72795 }
72796
72797
72798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
72799   void * jresult ;
72800   Dali::Toolkit::ScrollBar *result = 0 ;
72801
72802   {
72803     try {
72804       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
72805     } catch (std::out_of_range& e) {
72806       {
72807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72808       };
72809     } catch (std::exception& e) {
72810       {
72811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72812       };
72813     } catch (Dali::DaliException e) {
72814       {
72815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72816       };
72817     } catch (...) {
72818       {
72819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72820       };
72821     }
72822   }
72823
72824   jresult = (void *)result;
72825   return jresult;
72826 }
72827
72828
72829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
72830   void * jresult ;
72831   Dali::Toolkit::ScrollBar *arg1 = 0 ;
72832   Dali::Toolkit::ScrollBar *result = 0 ;
72833
72834   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72835   if (!arg1) {
72836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
72837     return 0;
72838   }
72839   {
72840     try {
72841       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
72842     } catch (std::out_of_range& e) {
72843       {
72844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72845       };
72846     } catch (std::exception& e) {
72847       {
72848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72849       };
72850     } catch (Dali::DaliException e) {
72851       {
72852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72853       };
72854     } catch (...) {
72855       {
72856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72857       };
72858     }
72859   }
72860
72861   jresult = (void *)result;
72862   return jresult;
72863 }
72864
72865
72866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
72867   void * jresult ;
72868   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72869   Dali::Toolkit::ScrollBar *arg2 = 0 ;
72870   Dali::Toolkit::ScrollBar *result = 0 ;
72871
72872   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72873   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
72874   if (!arg2) {
72875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
72876     return 0;
72877   }
72878   {
72879     try {
72880       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
72881     } catch (std::out_of_range& e) {
72882       {
72883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72884       };
72885     } catch (std::exception& e) {
72886       {
72887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72888       };
72889     } catch (Dali::DaliException e) {
72890       {
72891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72892       };
72893     } catch (...) {
72894       {
72895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72896       };
72897     }
72898   }
72899
72900   jresult = (void *)result;
72901   return jresult;
72902 }
72903
72904
72905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
72906   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72907
72908   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72909   {
72910     try {
72911       delete arg1;
72912     } catch (std::out_of_range& e) {
72913       {
72914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72915       };
72916     } catch (std::exception& e) {
72917       {
72918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72919       };
72920     } catch (Dali::DaliException e) {
72921       {
72922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72923       };
72924     } catch (...) {
72925       {
72926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72927       };
72928     }
72929   }
72930
72931 }
72932
72933
72934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
72935   void * jresult ;
72936   Dali::Toolkit::ScrollBar::Direction arg1 ;
72937   Dali::Toolkit::ScrollBar result;
72938
72939   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
72940   {
72941     try {
72942       result = Dali::Toolkit::ScrollBar::New(arg1);
72943     } catch (std::out_of_range& e) {
72944       {
72945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72946       };
72947     } catch (std::exception& e) {
72948       {
72949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72950       };
72951     } catch (Dali::DaliException e) {
72952       {
72953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72954       };
72955     } catch (...) {
72956       {
72957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72958       };
72959     }
72960   }
72961
72962   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
72963   return jresult;
72964 }
72965
72966
72967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
72968   void * jresult ;
72969   Dali::Toolkit::ScrollBar result;
72970
72971   {
72972     try {
72973       result = Dali::Toolkit::ScrollBar::New();
72974     } catch (std::out_of_range& e) {
72975       {
72976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72977       };
72978     } catch (std::exception& e) {
72979       {
72980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72981       };
72982     } catch (Dali::DaliException e) {
72983       {
72984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72985       };
72986     } catch (...) {
72987       {
72988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72989       };
72990     }
72991   }
72992
72993   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
72994   return jresult;
72995 }
72996
72997
72998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
72999   void * jresult ;
73000   Dali::BaseHandle arg1 ;
73001   Dali::BaseHandle *argp1 ;
73002   Dali::Toolkit::ScrollBar result;
73003
73004   argp1 = (Dali::BaseHandle *)jarg1;
73005   if (!argp1) {
73006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73007     return 0;
73008   }
73009   arg1 = *argp1;
73010   {
73011     try {
73012       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
73013     } catch (std::out_of_range& e) {
73014       {
73015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73016       };
73017     } catch (std::exception& e) {
73018       {
73019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73020       };
73021     } catch (Dali::DaliException e) {
73022       {
73023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73024       };
73025     } catch (...) {
73026       {
73027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73028       };
73029     }
73030   }
73031
73032   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73033   return jresult;
73034 }
73035
73036
73037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
73038   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73039   Dali::Handle arg2 ;
73040   Dali::Property::Index arg3 ;
73041   Dali::Property::Index arg4 ;
73042   Dali::Property::Index arg5 ;
73043   Dali::Property::Index arg6 ;
73044   Dali::Handle *argp2 ;
73045
73046   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73047   argp2 = (Dali::Handle *)jarg2;
73048   if (!argp2) {
73049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
73050     return ;
73051   }
73052   arg2 = *argp2;
73053   arg3 = (Dali::Property::Index)jarg3;
73054   arg4 = (Dali::Property::Index)jarg4;
73055   arg5 = (Dali::Property::Index)jarg5;
73056   arg6 = (Dali::Property::Index)jarg6;
73057   {
73058     try {
73059       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
73060     } catch (std::out_of_range& e) {
73061       {
73062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73063       };
73064     } catch (std::exception& e) {
73065       {
73066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73067       };
73068     } catch (Dali::DaliException e) {
73069       {
73070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73071       };
73072     } catch (...) {
73073       {
73074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73075       };
73076     }
73077   }
73078
73079 }
73080
73081
73082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
73083   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73084   Dali::Actor arg2 ;
73085   Dali::Actor *argp2 ;
73086
73087   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73088   argp2 = (Dali::Actor *)jarg2;
73089   if (!argp2) {
73090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73091     return ;
73092   }
73093   arg2 = *argp2;
73094   {
73095     try {
73096       (arg1)->SetScrollIndicator(arg2);
73097     } catch (std::out_of_range& e) {
73098       {
73099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73100       };
73101     } catch (std::exception& e) {
73102       {
73103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73104       };
73105     } catch (Dali::DaliException e) {
73106       {
73107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73108       };
73109     } catch (...) {
73110       {
73111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73112       };
73113     }
73114   }
73115
73116 }
73117
73118
73119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
73120   void * jresult ;
73121   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73122   Dali::Actor result;
73123
73124   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73125   {
73126     try {
73127       result = (arg1)->GetScrollIndicator();
73128     } catch (std::out_of_range& e) {
73129       {
73130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73131       };
73132     } catch (std::exception& e) {
73133       {
73134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73135       };
73136     } catch (Dali::DaliException e) {
73137       {
73138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73139       };
73140     } catch (...) {
73141       {
73142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73143       };
73144     }
73145   }
73146
73147   jresult = new Dali::Actor((const Dali::Actor &)result);
73148   return jresult;
73149 }
73150
73151
73152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
73153   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73154   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
73155
73156   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73157   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
73158   if (!arg2) {
73159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
73160     return ;
73161   }
73162   {
73163     try {
73164       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
73165     } catch (std::out_of_range& e) {
73166       {
73167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73168       };
73169     } catch (std::exception& e) {
73170       {
73171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73172       };
73173     } catch (Dali::DaliException e) {
73174       {
73175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73176       };
73177     } catch (...) {
73178       {
73179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73180       };
73181     }
73182   }
73183
73184 }
73185
73186
73187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
73188   void * jresult ;
73189   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73190
73191   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73192   {
73193     try {
73194       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()));
73195     } catch (std::out_of_range& e) {
73196       {
73197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73198       };
73199     } catch (std::exception& e) {
73200       {
73201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73202       };
73203     } catch (...) {
73204       {
73205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73206       };
73207     }
73208   }
73209   return jresult;
73210 }
73211
73212
73213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
73214   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73215   Dali::Toolkit::ScrollBar::Direction arg2 ;
73216
73217   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73218   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
73219   {
73220     try {
73221       (arg1)->SetScrollDirection(arg2);
73222     } catch (std::out_of_range& e) {
73223       {
73224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73225       };
73226     } catch (std::exception& e) {
73227       {
73228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73229       };
73230     } catch (Dali::DaliException e) {
73231       {
73232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73233       };
73234     } catch (...) {
73235       {
73236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73237       };
73238     }
73239   }
73240
73241 }
73242
73243
73244 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
73245   int jresult ;
73246   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73247   Dali::Toolkit::ScrollBar::Direction result;
73248
73249   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73250   {
73251     try {
73252       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
73253     } catch (std::out_of_range& e) {
73254       {
73255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73256       };
73257     } catch (std::exception& e) {
73258       {
73259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73260       };
73261     } catch (Dali::DaliException e) {
73262       {
73263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73264       };
73265     } catch (...) {
73266       {
73267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73268       };
73269     }
73270   }
73271
73272   jresult = (int)result;
73273   return jresult;
73274 }
73275
73276
73277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
73278   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73279   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
73280
73281   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73282   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
73283   {
73284     try {
73285       (arg1)->SetIndicatorHeightPolicy(arg2);
73286     } catch (std::out_of_range& e) {
73287       {
73288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73289       };
73290     } catch (std::exception& e) {
73291       {
73292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73293       };
73294     } catch (Dali::DaliException e) {
73295       {
73296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73297       };
73298     } catch (...) {
73299       {
73300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73301       };
73302     }
73303   }
73304
73305 }
73306
73307
73308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
73309   int jresult ;
73310   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73311   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
73312
73313   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73314   {
73315     try {
73316       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
73317     } catch (std::out_of_range& e) {
73318       {
73319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73320       };
73321     } catch (std::exception& e) {
73322       {
73323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73324       };
73325     } catch (Dali::DaliException e) {
73326       {
73327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73328       };
73329     } catch (...) {
73330       {
73331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73332       };
73333     }
73334   }
73335
73336   jresult = (int)result;
73337   return jresult;
73338 }
73339
73340
73341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
73342   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73343   float arg2 ;
73344
73345   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73346   arg2 = (float)jarg2;
73347   {
73348     try {
73349       (arg1)->SetIndicatorFixedHeight(arg2);
73350     } catch (std::out_of_range& e) {
73351       {
73352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73353       };
73354     } catch (std::exception& e) {
73355       {
73356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73357       };
73358     } catch (Dali::DaliException e) {
73359       {
73360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73361       };
73362     } catch (...) {
73363       {
73364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73365       };
73366     }
73367   }
73368
73369 }
73370
73371
73372 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
73373   float jresult ;
73374   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73375   float result;
73376
73377   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73378   {
73379     try {
73380       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
73381     } catch (std::out_of_range& e) {
73382       {
73383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73384       };
73385     } catch (std::exception& e) {
73386       {
73387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73388       };
73389     } catch (Dali::DaliException e) {
73390       {
73391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73392       };
73393     } catch (...) {
73394       {
73395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73396       };
73397     }
73398   }
73399
73400   jresult = result;
73401   return jresult;
73402 }
73403
73404
73405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
73406   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73407   float arg2 ;
73408
73409   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73410   arg2 = (float)jarg2;
73411   {
73412     try {
73413       (arg1)->SetIndicatorShowDuration(arg2);
73414     } catch (std::out_of_range& e) {
73415       {
73416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73417       };
73418     } catch (std::exception& e) {
73419       {
73420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73421       };
73422     } catch (Dali::DaliException e) {
73423       {
73424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73425       };
73426     } catch (...) {
73427       {
73428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73429       };
73430     }
73431   }
73432
73433 }
73434
73435
73436 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
73437   float jresult ;
73438   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73439   float result;
73440
73441   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73442   {
73443     try {
73444       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
73445     } catch (std::out_of_range& e) {
73446       {
73447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73448       };
73449     } catch (std::exception& e) {
73450       {
73451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73452       };
73453     } catch (Dali::DaliException e) {
73454       {
73455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73456       };
73457     } catch (...) {
73458       {
73459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73460       };
73461     }
73462   }
73463
73464   jresult = result;
73465   return jresult;
73466 }
73467
73468
73469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
73470   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73471   float arg2 ;
73472
73473   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73474   arg2 = (float)jarg2;
73475   {
73476     try {
73477       (arg1)->SetIndicatorHideDuration(arg2);
73478     } catch (std::out_of_range& e) {
73479       {
73480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73481       };
73482     } catch (std::exception& e) {
73483       {
73484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73485       };
73486     } catch (Dali::DaliException e) {
73487       {
73488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73489       };
73490     } catch (...) {
73491       {
73492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73493       };
73494     }
73495   }
73496
73497 }
73498
73499
73500 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
73501   float jresult ;
73502   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73503   float result;
73504
73505   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73506   {
73507     try {
73508       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
73509     } catch (std::out_of_range& e) {
73510       {
73511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73512       };
73513     } catch (std::exception& e) {
73514       {
73515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73516       };
73517     } catch (Dali::DaliException e) {
73518       {
73519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73520       };
73521     } catch (...) {
73522       {
73523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73524       };
73525     }
73526   }
73527
73528   jresult = result;
73529   return jresult;
73530 }
73531
73532
73533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
73534   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73535
73536   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73537   {
73538     try {
73539       (arg1)->ShowIndicator();
73540     } catch (std::out_of_range& e) {
73541       {
73542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73543       };
73544     } catch (std::exception& e) {
73545       {
73546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73547       };
73548     } catch (Dali::DaliException e) {
73549       {
73550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73551       };
73552     } catch (...) {
73553       {
73554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73555       };
73556     }
73557   }
73558
73559 }
73560
73561
73562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
73563   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73564
73565   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73566   {
73567     try {
73568       (arg1)->HideIndicator();
73569     } catch (std::out_of_range& e) {
73570       {
73571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73572       };
73573     } catch (std::exception& e) {
73574       {
73575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73576       };
73577     } catch (Dali::DaliException e) {
73578       {
73579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73580       };
73581     } catch (...) {
73582       {
73583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73584       };
73585     }
73586   }
73587
73588 }
73589
73590
73591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
73592   void * jresult ;
73593   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73594   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
73595
73596   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73597   {
73598     try {
73599       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
73600     } catch (std::out_of_range& e) {
73601       {
73602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73603       };
73604     } catch (std::exception& e) {
73605       {
73606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73607       };
73608     } catch (Dali::DaliException e) {
73609       {
73610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73611       };
73612     } catch (...) {
73613       {
73614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73615       };
73616     }
73617   }
73618
73619   jresult = (void *)result;
73620   return jresult;
73621 }
73622
73623
73624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
73625   void * jresult ;
73626   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73627   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
73628
73629   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73630   {
73631     try {
73632       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
73633     } catch (std::out_of_range& e) {
73634       {
73635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73636       };
73637     } catch (std::exception& e) {
73638       {
73639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73640       };
73641     } catch (Dali::DaliException e) {
73642       {
73643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73644       };
73645     } catch (...) {
73646       {
73647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73648       };
73649     }
73650   }
73651
73652   jresult = (void *)result;
73653   return jresult;
73654 }
73655
73656
73657 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
73658   int jresult ;
73659   int result;
73660
73661   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
73662   jresult = (int)result;
73663   return jresult;
73664 }
73665
73666
73667 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
73668   int jresult ;
73669   int result;
73670
73671   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
73672   jresult = (int)result;
73673   return jresult;
73674 }
73675
73676
73677 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
73678   int jresult ;
73679   int result;
73680
73681   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
73682   jresult = (int)result;
73683   return jresult;
73684 }
73685
73686
73687 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
73688   int jresult ;
73689   int result;
73690
73691   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
73692   jresult = (int)result;
73693   return jresult;
73694 }
73695
73696
73697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
73698   int jresult ;
73699   int result;
73700
73701   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
73702   jresult = (int)result;
73703   return jresult;
73704 }
73705
73706
73707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
73708   int jresult ;
73709   int result;
73710
73711   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
73712   jresult = (int)result;
73713   return jresult;
73714 }
73715
73716
73717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
73718   int jresult ;
73719   int result;
73720
73721   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
73722   jresult = (int)result;
73723   return jresult;
73724 }
73725
73726
73727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
73728   int jresult ;
73729   int result;
73730
73731   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
73732   jresult = (int)result;
73733   return jresult;
73734 }
73735
73736
73737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
73738   int jresult ;
73739   int result;
73740
73741   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
73742   jresult = (int)result;
73743   return jresult;
73744 }
73745
73746
73747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
73748   int jresult ;
73749   int result;
73750
73751   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
73752   jresult = (int)result;
73753   return jresult;
73754 }
73755
73756
73757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
73758   int jresult ;
73759   int result;
73760
73761   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
73762   jresult = (int)result;
73763   return jresult;
73764 }
73765
73766
73767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
73768   int jresult ;
73769   int result;
73770
73771   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
73772   jresult = (int)result;
73773   return jresult;
73774 }
73775
73776
73777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
73778   int jresult ;
73779   int result;
73780
73781   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
73782   jresult = (int)result;
73783   return jresult;
73784 }
73785
73786
73787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
73788   int jresult ;
73789   int result;
73790
73791   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
73792   jresult = (int)result;
73793   return jresult;
73794 }
73795
73796
73797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
73798   void * jresult ;
73799   Dali::Toolkit::Scrollable::Property *result = 0 ;
73800
73801   {
73802     try {
73803       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
73804     } catch (std::out_of_range& e) {
73805       {
73806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73807       };
73808     } catch (std::exception& e) {
73809       {
73810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73811       };
73812     } catch (Dali::DaliException e) {
73813       {
73814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73815       };
73816     } catch (...) {
73817       {
73818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73819       };
73820     }
73821   }
73822
73823   jresult = (void *)result;
73824   return jresult;
73825 }
73826
73827
73828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
73829   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
73830
73831   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
73832   {
73833     try {
73834       delete arg1;
73835     } catch (std::out_of_range& e) {
73836       {
73837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73838       };
73839     } catch (std::exception& e) {
73840       {
73841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73842       };
73843     } catch (Dali::DaliException e) {
73844       {
73845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73846       };
73847     } catch (...) {
73848       {
73849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73850       };
73851     }
73852   }
73853
73854 }
73855
73856
73857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
73858   void * jresult ;
73859   Dali::Toolkit::Scrollable *result = 0 ;
73860
73861   {
73862     try {
73863       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
73864     } catch (std::out_of_range& e) {
73865       {
73866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73867       };
73868     } catch (std::exception& e) {
73869       {
73870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73871       };
73872     } catch (Dali::DaliException e) {
73873       {
73874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73875       };
73876     } catch (...) {
73877       {
73878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73879       };
73880     }
73881   }
73882
73883   jresult = (void *)result;
73884   return jresult;
73885 }
73886
73887
73888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
73889   void * jresult ;
73890   Dali::Toolkit::Scrollable *arg1 = 0 ;
73891   Dali::Toolkit::Scrollable *result = 0 ;
73892
73893   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73894   if (!arg1) {
73895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
73896     return 0;
73897   }
73898   {
73899     try {
73900       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
73901     } catch (std::out_of_range& e) {
73902       {
73903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73904       };
73905     } catch (std::exception& e) {
73906       {
73907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73908       };
73909     } catch (Dali::DaliException e) {
73910       {
73911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73912       };
73913     } catch (...) {
73914       {
73915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73916       };
73917     }
73918   }
73919
73920   jresult = (void *)result;
73921   return jresult;
73922 }
73923
73924
73925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
73926   void * jresult ;
73927   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73928   Dali::Toolkit::Scrollable *arg2 = 0 ;
73929   Dali::Toolkit::Scrollable *result = 0 ;
73930
73931   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73932   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
73933   if (!arg2) {
73934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
73935     return 0;
73936   }
73937   {
73938     try {
73939       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
73940     } catch (std::out_of_range& e) {
73941       {
73942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73943       };
73944     } catch (std::exception& e) {
73945       {
73946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73947       };
73948     } catch (Dali::DaliException e) {
73949       {
73950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73951       };
73952     } catch (...) {
73953       {
73954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73955       };
73956     }
73957   }
73958
73959   jresult = (void *)result;
73960   return jresult;
73961 }
73962
73963
73964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
73965   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73966
73967   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73968   {
73969     try {
73970       delete arg1;
73971     } catch (std::out_of_range& e) {
73972       {
73973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73974       };
73975     } catch (std::exception& e) {
73976       {
73977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73978       };
73979     } catch (Dali::DaliException e) {
73980       {
73981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73982       };
73983     } catch (...) {
73984       {
73985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73986       };
73987     }
73988   }
73989
73990 }
73991
73992
73993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
73994   void * jresult ;
73995   Dali::BaseHandle arg1 ;
73996   Dali::BaseHandle *argp1 ;
73997   Dali::Toolkit::Scrollable result;
73998
73999   argp1 = (Dali::BaseHandle *)jarg1;
74000   if (!argp1) {
74001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74002     return 0;
74003   }
74004   arg1 = *argp1;
74005   {
74006     try {
74007       result = Dali::Toolkit::Scrollable::DownCast(arg1);
74008     } catch (std::out_of_range& e) {
74009       {
74010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74011       };
74012     } catch (std::exception& e) {
74013       {
74014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74015       };
74016     } catch (Dali::DaliException e) {
74017       {
74018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74019       };
74020     } catch (...) {
74021       {
74022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74023       };
74024     }
74025   }
74026
74027   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
74028   return jresult;
74029 }
74030
74031
74032 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
74033   unsigned int jresult ;
74034   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74035   bool result;
74036
74037   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74038   {
74039     try {
74040       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
74041     } catch (std::out_of_range& e) {
74042       {
74043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74044       };
74045     } catch (std::exception& e) {
74046       {
74047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74048       };
74049     } catch (Dali::DaliException e) {
74050       {
74051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74052       };
74053     } catch (...) {
74054       {
74055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74056       };
74057     }
74058   }
74059
74060   jresult = result;
74061   return jresult;
74062 }
74063
74064
74065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
74066   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74067   bool arg2 ;
74068
74069   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74070   arg2 = jarg2 ? true : false;
74071   {
74072     try {
74073       (arg1)->SetOvershootEnabled(arg2);
74074     } catch (std::out_of_range& e) {
74075       {
74076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74077       };
74078     } catch (std::exception& e) {
74079       {
74080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74081       };
74082     } catch (Dali::DaliException e) {
74083       {
74084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74085       };
74086     } catch (...) {
74087       {
74088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74089       };
74090     }
74091   }
74092
74093 }
74094
74095
74096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
74097   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74098   Dali::Vector4 *arg2 = 0 ;
74099
74100   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74101   arg2 = (Dali::Vector4 *)jarg2;
74102   if (!arg2) {
74103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
74104     return ;
74105   }
74106   {
74107     try {
74108       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
74109     } catch (std::out_of_range& e) {
74110       {
74111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74112       };
74113     } catch (std::exception& e) {
74114       {
74115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74116       };
74117     } catch (Dali::DaliException e) {
74118       {
74119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74120       };
74121     } catch (...) {
74122       {
74123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74124       };
74125     }
74126   }
74127
74128 }
74129
74130
74131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
74132   void * jresult ;
74133   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74134   Dali::Vector4 result;
74135
74136   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74137   {
74138     try {
74139       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
74140     } catch (std::out_of_range& e) {
74141       {
74142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74143       };
74144     } catch (std::exception& e) {
74145       {
74146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74147       };
74148     } catch (Dali::DaliException e) {
74149       {
74150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74151       };
74152     } catch (...) {
74153       {
74154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74155       };
74156     }
74157   }
74158
74159   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
74160   return jresult;
74161 }
74162
74163
74164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
74165   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74166   float arg2 ;
74167
74168   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74169   arg2 = (float)jarg2;
74170   {
74171     try {
74172       (arg1)->SetOvershootAnimationSpeed(arg2);
74173     } catch (std::out_of_range& e) {
74174       {
74175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74176       };
74177     } catch (std::exception& e) {
74178       {
74179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74180       };
74181     } catch (Dali::DaliException e) {
74182       {
74183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74184       };
74185     } catch (...) {
74186       {
74187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74188       };
74189     }
74190   }
74191
74192 }
74193
74194
74195 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
74196   float jresult ;
74197   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74198   float result;
74199
74200   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74201   {
74202     try {
74203       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
74204     } catch (std::out_of_range& e) {
74205       {
74206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74207       };
74208     } catch (std::exception& e) {
74209       {
74210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74211       };
74212     } catch (Dali::DaliException e) {
74213       {
74214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74215       };
74216     } catch (...) {
74217       {
74218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74219       };
74220     }
74221   }
74222
74223   jresult = result;
74224   return jresult;
74225 }
74226
74227
74228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
74229   void * jresult ;
74230   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74231   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
74232
74233   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74234   {
74235     try {
74236       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
74237     } catch (std::out_of_range& e) {
74238       {
74239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74240       };
74241     } catch (std::exception& e) {
74242       {
74243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74244       };
74245     } catch (Dali::DaliException e) {
74246       {
74247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74248       };
74249     } catch (...) {
74250       {
74251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74252       };
74253     }
74254   }
74255
74256   jresult = (void *)result;
74257   return jresult;
74258 }
74259
74260
74261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
74262   void * jresult ;
74263   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74264   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
74265
74266   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74267   {
74268     try {
74269       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
74270     } catch (std::out_of_range& e) {
74271       {
74272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74273       };
74274     } catch (std::exception& e) {
74275       {
74276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74277       };
74278     } catch (Dali::DaliException e) {
74279       {
74280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74281       };
74282     } catch (...) {
74283       {
74284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74285       };
74286     }
74287   }
74288
74289   jresult = (void *)result;
74290   return jresult;
74291 }
74292
74293
74294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
74295   void * jresult ;
74296   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74297   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
74298
74299   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74300   {
74301     try {
74302       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
74303     } catch (std::out_of_range& e) {
74304       {
74305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74306       };
74307     } catch (std::exception& e) {
74308       {
74309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74310       };
74311     } catch (Dali::DaliException e) {
74312       {
74313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74314       };
74315     } catch (...) {
74316       {
74317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74318       };
74319     }
74320   }
74321
74322   jresult = (void *)result;
74323   return jresult;
74324 }
74325
74326
74327 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
74328   unsigned int jresult ;
74329   Dali::Toolkit::ControlOrientation::Type arg1 ;
74330   bool result;
74331
74332   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74333   {
74334     try {
74335       result = (bool)Dali::Toolkit::IsVertical(arg1);
74336     } catch (std::out_of_range& e) {
74337       {
74338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74339       };
74340     } catch (std::exception& e) {
74341       {
74342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74343       };
74344     } catch (Dali::DaliException e) {
74345       {
74346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74347       };
74348     } catch (...) {
74349       {
74350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74351       };
74352     }
74353   }
74354
74355   jresult = result;
74356   return jresult;
74357 }
74358
74359
74360 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
74361   unsigned int jresult ;
74362   Dali::Toolkit::ControlOrientation::Type arg1 ;
74363   bool result;
74364
74365   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74366   {
74367     try {
74368       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
74369     } catch (std::out_of_range& e) {
74370       {
74371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74372       };
74373     } catch (std::exception& e) {
74374       {
74375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74376       };
74377     } catch (Dali::DaliException e) {
74378       {
74379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74380       };
74381     } catch (...) {
74382       {
74383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74384       };
74385     }
74386   }
74387
74388   jresult = result;
74389   return jresult;
74390 }
74391
74392
74393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
74394   void * jresult ;
74395   unsigned int arg1 ;
74396   unsigned int arg2 ;
74397   Dali::Toolkit::ItemRange *result = 0 ;
74398
74399   arg1 = (unsigned int)jarg1;
74400   arg2 = (unsigned int)jarg2;
74401   {
74402     try {
74403       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
74404     } catch (std::out_of_range& e) {
74405       {
74406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74407       };
74408     } catch (std::exception& e) {
74409       {
74410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74411       };
74412     } catch (Dali::DaliException e) {
74413       {
74414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74415       };
74416     } catch (...) {
74417       {
74418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74419       };
74420     }
74421   }
74422
74423   jresult = (void *)result;
74424   return jresult;
74425 }
74426
74427
74428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
74429   void * jresult ;
74430   Dali::Toolkit::ItemRange *arg1 = 0 ;
74431   Dali::Toolkit::ItemRange *result = 0 ;
74432
74433   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74434   if (!arg1) {
74435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74436     return 0;
74437   }
74438   {
74439     try {
74440       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
74441     } catch (std::out_of_range& e) {
74442       {
74443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74444       };
74445     } catch (std::exception& e) {
74446       {
74447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74448       };
74449     } catch (Dali::DaliException e) {
74450       {
74451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74452       };
74453     } catch (...) {
74454       {
74455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74456       };
74457     }
74458   }
74459
74460   jresult = (void *)result;
74461   return jresult;
74462 }
74463
74464
74465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
74466   void * jresult ;
74467   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74468   Dali::Toolkit::ItemRange *arg2 = 0 ;
74469   Dali::Toolkit::ItemRange *result = 0 ;
74470
74471   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74472   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74473   if (!arg2) {
74474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74475     return 0;
74476   }
74477   {
74478     try {
74479       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
74480     } catch (std::out_of_range& e) {
74481       {
74482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74483       };
74484     } catch (std::exception& e) {
74485       {
74486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74487       };
74488     } catch (Dali::DaliException e) {
74489       {
74490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74491       };
74492     } catch (...) {
74493       {
74494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74495       };
74496     }
74497   }
74498
74499   jresult = (void *)result;
74500   return jresult;
74501 }
74502
74503
74504 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
74505   unsigned int jresult ;
74506   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74507   unsigned int arg2 ;
74508   bool result;
74509
74510   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74511   arg2 = (unsigned int)jarg2;
74512   {
74513     try {
74514       result = (bool)(arg1)->Within(arg2);
74515     } catch (std::out_of_range& e) {
74516       {
74517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74518       };
74519     } catch (std::exception& e) {
74520       {
74521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74522       };
74523     } catch (Dali::DaliException e) {
74524       {
74525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74526       };
74527     } catch (...) {
74528       {
74529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74530       };
74531     }
74532   }
74533
74534   jresult = result;
74535   return jresult;
74536 }
74537
74538
74539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
74540   void * jresult ;
74541   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74542   Dali::Toolkit::ItemRange *arg2 = 0 ;
74543   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
74544
74545   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74546   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74547   if (!arg2) {
74548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74549     return 0;
74550   }
74551   {
74552     try {
74553       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
74554     } catch (std::out_of_range& e) {
74555       {
74556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74557       };
74558     } catch (std::exception& e) {
74559       {
74560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74561       };
74562     } catch (Dali::DaliException e) {
74563       {
74564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74565       };
74566     } catch (...) {
74567       {
74568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74569       };
74570     }
74571   }
74572
74573   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
74574   return jresult;
74575 }
74576
74577
74578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
74579   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74580   unsigned int arg2 ;
74581
74582   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74583   arg2 = (unsigned int)jarg2;
74584   if (arg1) (arg1)->begin = arg2;
74585 }
74586
74587
74588 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
74589   unsigned int jresult ;
74590   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74591   unsigned int result;
74592
74593   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74594   result = (unsigned int) ((arg1)->begin);
74595   jresult = result;
74596   return jresult;
74597 }
74598
74599
74600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
74601   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74602   unsigned int arg2 ;
74603
74604   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74605   arg2 = (unsigned int)jarg2;
74606   if (arg1) (arg1)->end = arg2;
74607 }
74608
74609
74610 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
74611   unsigned int jresult ;
74612   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74613   unsigned int result;
74614
74615   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74616   result = (unsigned int) ((arg1)->end);
74617   jresult = result;
74618   return jresult;
74619 }
74620
74621
74622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
74623   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74624
74625   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74626   {
74627     try {
74628       delete arg1;
74629     } catch (std::out_of_range& e) {
74630       {
74631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74632       };
74633     } catch (std::exception& e) {
74634       {
74635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74636       };
74637     } catch (Dali::DaliException e) {
74638       {
74639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74640       };
74641     } catch (...) {
74642       {
74643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74644       };
74645     }
74646   }
74647
74648 }
74649
74650
74651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
74652   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74653
74654   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74655   {
74656     try {
74657       delete arg1;
74658     } catch (std::out_of_range& e) {
74659       {
74660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74661       };
74662     } catch (std::exception& e) {
74663       {
74664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74665       };
74666     } catch (Dali::DaliException e) {
74667       {
74668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74669       };
74670     } catch (...) {
74671       {
74672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74673       };
74674     }
74675   }
74676
74677 }
74678
74679
74680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
74681   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74682   Dali::Toolkit::ControlOrientation::Type arg2 ;
74683
74684   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74685   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
74686   {
74687     try {
74688       (arg1)->SetOrientation(arg2);
74689     } catch (std::out_of_range& e) {
74690       {
74691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74692       };
74693     } catch (std::exception& e) {
74694       {
74695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74696       };
74697     } catch (Dali::DaliException e) {
74698       {
74699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74700       };
74701     } catch (...) {
74702       {
74703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74704       };
74705     }
74706   }
74707
74708 }
74709
74710
74711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
74712   int jresult ;
74713   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74714   Dali::Toolkit::ControlOrientation::Type result;
74715
74716   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74717   {
74718     try {
74719       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
74720     } catch (std::out_of_range& e) {
74721       {
74722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74723       };
74724     } catch (std::exception& e) {
74725       {
74726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74727       };
74728     } catch (Dali::DaliException e) {
74729       {
74730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74731       };
74732     } catch (...) {
74733       {
74734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74735       };
74736     }
74737   }
74738
74739   jresult = (int)result;
74740   return jresult;
74741 }
74742
74743
74744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
74745   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74746   Dali::Property::Map *arg2 = 0 ;
74747
74748   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74749   arg2 = (Dali::Property::Map *)jarg2;
74750   if (!arg2) {
74751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
74752     return ;
74753   }
74754   {
74755     try {
74756       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
74757     } catch (std::out_of_range& e) {
74758       {
74759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74760       };
74761     } catch (std::exception& e) {
74762       {
74763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74764       };
74765     } catch (Dali::DaliException e) {
74766       {
74767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74768       };
74769     } catch (...) {
74770       {
74771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74772       };
74773     }
74774   }
74775
74776 }
74777
74778
74779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
74780   void * jresult ;
74781   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74782   Dali::Property::Map result;
74783
74784   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74785   {
74786     try {
74787       result = (arg1)->GetLayoutProperties();
74788     } catch (std::out_of_range& e) {
74789       {
74790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74791       };
74792     } catch (std::exception& e) {
74793       {
74794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74795       };
74796     } catch (Dali::DaliException e) {
74797       {
74798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74799       };
74800     } catch (...) {
74801       {
74802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74803       };
74804     }
74805   }
74806
74807   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
74808   return jresult;
74809 }
74810
74811
74812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
74813   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74814   unsigned int arg2 ;
74815   Dali::Vector3 *arg3 = 0 ;
74816   Dali::Vector3 *arg4 = 0 ;
74817
74818   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74819   arg2 = (unsigned int)jarg2;
74820   arg3 = (Dali::Vector3 *)jarg3;
74821   if (!arg3) {
74822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74823     return ;
74824   }
74825   arg4 = (Dali::Vector3 *)jarg4;
74826   if (!arg4) {
74827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
74828     return ;
74829   }
74830   {
74831     try {
74832       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
74833     } catch (std::out_of_range& e) {
74834       {
74835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74836       };
74837     } catch (std::exception& e) {
74838       {
74839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74840       };
74841     } catch (Dali::DaliException e) {
74842       {
74843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74844       };
74845     } catch (...) {
74846       {
74847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74848       };
74849     }
74850   }
74851
74852 }
74853
74854
74855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
74856   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74857   Dali::Vector3 *arg2 = 0 ;
74858
74859   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74860   arg2 = (Dali::Vector3 *)jarg2;
74861   if (!arg2) {
74862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74863     return ;
74864   }
74865   {
74866     try {
74867       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
74868     } catch (std::out_of_range& e) {
74869       {
74870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74871       };
74872     } catch (std::exception& e) {
74873       {
74874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74875       };
74876     } catch (Dali::DaliException e) {
74877       {
74878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74879       };
74880     } catch (...) {
74881       {
74882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74883       };
74884     }
74885   }
74886
74887 }
74888
74889
74890 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
74891   float jresult ;
74892   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74893   unsigned int arg2 ;
74894   Dali::Vector3 arg3 ;
74895   Dali::Vector3 *argp3 ;
74896   float result;
74897
74898   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74899   arg2 = (unsigned int)jarg2;
74900   argp3 = (Dali::Vector3 *)jarg3;
74901   if (!argp3) {
74902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
74903     return 0;
74904   }
74905   arg3 = *argp3;
74906   {
74907     try {
74908       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
74909     } catch (std::out_of_range& e) {
74910       {
74911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74912       };
74913     } catch (std::exception& e) {
74914       {
74915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74916       };
74917     } catch (Dali::DaliException e) {
74918       {
74919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74920       };
74921     } catch (...) {
74922       {
74923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74924       };
74925     }
74926   }
74927
74928   jresult = result;
74929   return jresult;
74930 }
74931
74932
74933 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
74934   float jresult ;
74935   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74936   float arg2 ;
74937   float result;
74938
74939   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74940   arg2 = (float)jarg2;
74941   {
74942     try {
74943       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
74944     } catch (std::out_of_range& e) {
74945       {
74946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74947       };
74948     } catch (std::exception& e) {
74949       {
74950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74951       };
74952     } catch (Dali::DaliException e) {
74953       {
74954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74955       };
74956     } catch (...) {
74957       {
74958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74959       };
74960     }
74961   }
74962
74963   jresult = result;
74964   return jresult;
74965 }
74966
74967
74968 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
74969   float jresult ;
74970   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74971   unsigned int arg2 ;
74972   float result;
74973
74974   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74975   arg2 = (unsigned int)jarg2;
74976   {
74977     try {
74978       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
74979     } catch (std::out_of_range& e) {
74980       {
74981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74982       };
74983     } catch (std::exception& e) {
74984       {
74985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74986       };
74987     } catch (Dali::DaliException e) {
74988       {
74989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74990       };
74991     } catch (...) {
74992       {
74993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74994       };
74995     }
74996   }
74997
74998   jresult = result;
74999   return jresult;
75000 }
75001
75002
75003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
75004   void * jresult ;
75005   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75006   float arg2 ;
75007   Dali::Vector3 arg3 ;
75008   Dali::Vector3 *argp3 ;
75009   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
75010
75011   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75012   arg2 = (float)jarg2;
75013   argp3 = (Dali::Vector3 *)jarg3;
75014   if (!argp3) {
75015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75016     return 0;
75017   }
75018   arg3 = *argp3;
75019   {
75020     try {
75021       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
75022     } catch (std::out_of_range& e) {
75023       {
75024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75025       };
75026     } catch (std::exception& e) {
75027       {
75028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75029       };
75030     } catch (Dali::DaliException e) {
75031       {
75032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75033       };
75034     } catch (...) {
75035       {
75036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75037       };
75038     }
75039   }
75040
75041   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
75042   return jresult;
75043 }
75044
75045
75046 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75047   float jresult ;
75048   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75049   int arg2 ;
75050   float arg3 ;
75051   Dali::Vector3 *arg4 = 0 ;
75052   float result;
75053
75054   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75055   arg2 = (int)jarg2;
75056   arg3 = (float)jarg3;
75057   arg4 = (Dali::Vector3 *)jarg4;
75058   if (!arg4) {
75059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75060     return 0;
75061   }
75062   {
75063     try {
75064       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75065     } catch (std::out_of_range& e) {
75066       {
75067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75068       };
75069     } catch (std::exception& e) {
75070       {
75071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75072       };
75073     } catch (Dali::DaliException e) {
75074       {
75075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75076       };
75077     } catch (...) {
75078       {
75079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75080       };
75081     }
75082   }
75083
75084   jresult = result;
75085   return jresult;
75086 }
75087
75088
75089 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
75090   unsigned int jresult ;
75091   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75092   Dali::Vector3 arg2 ;
75093   Dali::Vector3 *argp2 ;
75094   unsigned int result;
75095
75096   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75097   argp2 = (Dali::Vector3 *)jarg2;
75098   if (!argp2) {
75099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75100     return 0;
75101   }
75102   arg2 = *argp2;
75103   {
75104     try {
75105       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
75106     } catch (std::out_of_range& e) {
75107       {
75108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75109       };
75110     } catch (std::exception& e) {
75111       {
75112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75113       };
75114     } catch (Dali::DaliException e) {
75115       {
75116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75117       };
75118     } catch (...) {
75119       {
75120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75121       };
75122     }
75123   }
75124
75125   jresult = result;
75126   return jresult;
75127 }
75128
75129
75130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
75131   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75132   unsigned int arg2 ;
75133   Dali::Vector3 *arg3 = 0 ;
75134   Dali::Vector3 *arg4 = 0 ;
75135
75136   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75137   arg2 = (unsigned int)jarg2;
75138   arg3 = (Dali::Vector3 *)jarg3;
75139   if (!arg3) {
75140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75141     return ;
75142   }
75143   arg4 = (Dali::Vector3 *)jarg4;
75144   if (!arg4) {
75145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
75146     return ;
75147   }
75148   {
75149     try {
75150       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
75151     } catch (std::out_of_range& e) {
75152       {
75153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75154       };
75155     } catch (std::exception& e) {
75156       {
75157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75158       };
75159     } catch (Dali::DaliException e) {
75160       {
75161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75162       };
75163     } catch (...) {
75164       {
75165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75166       };
75167     }
75168   }
75169
75170 }
75171
75172
75173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
75174   void * jresult ;
75175   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75176   Dali::Degree result;
75177
75178   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75179   {
75180     try {
75181       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
75182     } catch (std::out_of_range& e) {
75183       {
75184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75185       };
75186     } catch (std::exception& e) {
75187       {
75188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75189       };
75190     } catch (Dali::DaliException e) {
75191       {
75192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75193       };
75194     } catch (...) {
75195       {
75196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75197       };
75198     }
75199   }
75200
75201   jresult = new Dali::Degree((const Dali::Degree &)result);
75202   return jresult;
75203 }
75204
75205
75206 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
75207   float jresult ;
75208   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75209   float result;
75210
75211   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75212   {
75213     try {
75214       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
75215     } catch (std::out_of_range& e) {
75216       {
75217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75218       };
75219     } catch (std::exception& e) {
75220       {
75221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75222       };
75223     } catch (Dali::DaliException e) {
75224       {
75225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75226       };
75227     } catch (...) {
75228       {
75229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75230       };
75231     }
75232   }
75233
75234   jresult = result;
75235   return jresult;
75236 }
75237
75238
75239 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
75240   float jresult ;
75241   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75242   float result;
75243
75244   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75245   {
75246     try {
75247       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
75248     } catch (std::out_of_range& e) {
75249       {
75250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75251       };
75252     } catch (std::exception& e) {
75253       {
75254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75255       };
75256     } catch (Dali::DaliException e) {
75257       {
75258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75259       };
75260     } catch (...) {
75261       {
75262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75263       };
75264     }
75265   }
75266
75267   jresult = result;
75268   return jresult;
75269 }
75270
75271
75272 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
75273   float jresult ;
75274   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75275   float result;
75276
75277   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75278   {
75279     try {
75280       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
75281     } catch (std::out_of_range& e) {
75282       {
75283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75284       };
75285     } catch (std::exception& e) {
75286       {
75287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75288       };
75289     } catch (Dali::DaliException e) {
75290       {
75291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75292       };
75293     } catch (...) {
75294       {
75295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75296       };
75297     }
75298   }
75299
75300   jresult = result;
75301   return jresult;
75302 }
75303
75304
75305 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
75306   int jresult ;
75307   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75308   int arg2 ;
75309   int arg3 ;
75310   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
75311   bool arg5 ;
75312   int result;
75313
75314   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75315   arg2 = (int)jarg2;
75316   arg3 = (int)jarg3;
75317   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
75318   arg5 = jarg5 ? true : false;
75319   {
75320     try {
75321       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
75322     } catch (std::out_of_range& e) {
75323       {
75324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75325       };
75326     } catch (std::exception& e) {
75327       {
75328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75329       };
75330     } catch (Dali::DaliException e) {
75331       {
75332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75333       };
75334     } catch (...) {
75335       {
75336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75337       };
75338     }
75339   }
75340
75341   jresult = result;
75342   return jresult;
75343 }
75344
75345
75346 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
75347   float jresult ;
75348   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75349   float result;
75350
75351   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75352   {
75353     try {
75354       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
75355     } catch (std::out_of_range& e) {
75356       {
75357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75358       };
75359     } catch (std::exception& e) {
75360       {
75361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75362       };
75363     } catch (Dali::DaliException e) {
75364       {
75365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75366       };
75367     } catch (...) {
75368       {
75369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75370       };
75371     }
75372   }
75373
75374   jresult = result;
75375   return jresult;
75376 }
75377
75378
75379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
75380   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75381   Dali::Actor *arg2 = 0 ;
75382   int arg3 ;
75383   Dali::Vector3 *arg4 = 0 ;
75384   Dali::Actor *arg5 = 0 ;
75385
75386   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75387   arg2 = (Dali::Actor *)jarg2;
75388   if (!arg2) {
75389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75390     return ;
75391   }
75392   arg3 = (int)jarg3;
75393   arg4 = (Dali::Vector3 *)jarg4;
75394   if (!arg4) {
75395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75396     return ;
75397   }
75398   arg5 = (Dali::Actor *)jarg5;
75399   if (!arg5) {
75400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
75401     return ;
75402   }
75403   {
75404     try {
75405       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
75406     } catch (std::out_of_range& e) {
75407       {
75408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75409       };
75410     } catch (std::exception& e) {
75411       {
75412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75413       };
75414     } catch (Dali::DaliException e) {
75415       {
75416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75417       };
75418     } catch (...) {
75419       {
75420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75421       };
75422     }
75423   }
75424
75425 }
75426
75427
75428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75429   void * jresult ;
75430   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75431   int arg2 ;
75432   float arg3 ;
75433   Dali::Vector3 *arg4 = 0 ;
75434   Dali::Vector3 result;
75435
75436   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75437   arg2 = (int)jarg2;
75438   arg3 = (float)jarg3;
75439   arg4 = (Dali::Vector3 *)jarg4;
75440   if (!arg4) {
75441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75442     return 0;
75443   }
75444   {
75445     try {
75446       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75447     } catch (std::out_of_range& e) {
75448       {
75449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75450       };
75451     } catch (std::exception& e) {
75452       {
75453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75454       };
75455     } catch (Dali::DaliException e) {
75456       {
75457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75458       };
75459     } catch (...) {
75460       {
75461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75462       };
75463     }
75464   }
75465
75466   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
75467   return jresult;
75468 }
75469
75470
75471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
75472   void * jresult ;
75473   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
75474   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75475
75476   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
75477   {
75478     try {
75479       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
75480     } catch (std::out_of_range& e) {
75481       {
75482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75483       };
75484     } catch (std::exception& e) {
75485       {
75486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75487       };
75488     } catch (Dali::DaliException e) {
75489       {
75490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75491       };
75492     } catch (...) {
75493       {
75494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75495       };
75496     }
75497   }
75498
75499   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75500   return jresult;
75501 }
75502
75503
75504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
75505   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75506
75507   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75508   {
75509     try {
75510       delete arg1;
75511     } catch (std::out_of_range& e) {
75512       {
75513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75514       };
75515     } catch (std::exception& e) {
75516       {
75517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75518       };
75519     } catch (Dali::DaliException e) {
75520       {
75521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75522       };
75523     } catch (...) {
75524       {
75525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75526       };
75527     }
75528   }
75529
75530 }
75531
75532
75533 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
75534   unsigned int jresult ;
75535   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75536   unsigned int result;
75537
75538   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75539   {
75540     try {
75541       result = (unsigned int)(arg1)->GetNumberOfItems();
75542     } catch (std::out_of_range& e) {
75543       {
75544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75545       };
75546     } catch (std::exception& e) {
75547       {
75548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75549       };
75550     } catch (Dali::DaliException e) {
75551       {
75552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75553       };
75554     } catch (...) {
75555       {
75556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75557       };
75558     }
75559   }
75560
75561   jresult = result;
75562   return jresult;
75563 }
75564
75565
75566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
75567   void * jresult ;
75568   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75569   unsigned int arg2 ;
75570   Dali::Actor result;
75571
75572   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75573   arg2 = (unsigned int)jarg2;
75574   {
75575     try {
75576       result = (arg1)->NewItem(arg2);
75577     } catch (std::out_of_range& e) {
75578       {
75579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75580       };
75581     } catch (std::exception& e) {
75582       {
75583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75584       };
75585     } catch (Dali::DaliException e) {
75586       {
75587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75588       };
75589     } catch (...) {
75590       {
75591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75592       };
75593     }
75594   }
75595
75596   jresult = new Dali::Actor((const Dali::Actor &)result);
75597   return jresult;
75598 }
75599
75600
75601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
75602   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75603   unsigned int arg2 ;
75604   Dali::Actor arg3 ;
75605   Dali::Actor *argp3 ;
75606
75607   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75608   arg2 = (unsigned int)jarg2;
75609   argp3 = (Dali::Actor *)jarg3;
75610   if (!argp3) {
75611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75612     return ;
75613   }
75614   arg3 = *argp3;
75615   {
75616     try {
75617       (arg1)->ItemReleased(arg2,arg3);
75618     } catch (std::out_of_range& e) {
75619       {
75620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75621       };
75622     } catch (std::exception& e) {
75623       {
75624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75625       };
75626     } catch (Dali::DaliException e) {
75627       {
75628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75629       };
75630     } catch (...) {
75631       {
75632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75633       };
75634     }
75635   }
75636
75637 }
75638
75639
75640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
75641   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75642   unsigned int arg2 ;
75643   Dali::Actor arg3 ;
75644   Dali::Actor *argp3 ;
75645
75646   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75647   arg2 = (unsigned int)jarg2;
75648   argp3 = (Dali::Actor *)jarg3;
75649   if (!argp3) {
75650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75651     return ;
75652   }
75653   arg3 = *argp3;
75654   {
75655     try {
75656       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
75657     } catch (std::out_of_range& e) {
75658       {
75659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75660       };
75661     } catch (std::exception& e) {
75662       {
75663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75664       };
75665     } catch (Dali::DaliException e) {
75666       {
75667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75668       };
75669     } catch (...) {
75670       {
75671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75672       };
75673     }
75674   }
75675
75676 }
75677
75678
75679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
75680   void * jresult ;
75681   Dali::Toolkit::ItemFactory *result = 0 ;
75682
75683   {
75684     try {
75685       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
75686     } catch (std::out_of_range& e) {
75687       {
75688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75689       };
75690     } catch (std::exception& e) {
75691       {
75692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75693       };
75694     } catch (Dali::DaliException e) {
75695       {
75696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75697       };
75698     } catch (...) {
75699       {
75700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75701       };
75702     }
75703   }
75704
75705   jresult = (void *)result;
75706   return jresult;
75707 }
75708
75709
75710 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) {
75711   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
75712   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
75713   if (director) {
75714     director->swig_connect_director(callback0, callback1, callback2);
75715   }
75716 }
75717
75718
75719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
75720   int jresult ;
75721   int result;
75722
75723   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
75724   jresult = (int)result;
75725   return jresult;
75726 }
75727
75728
75729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
75730   int jresult ;
75731   int result;
75732
75733   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
75734   jresult = (int)result;
75735   return jresult;
75736 }
75737
75738
75739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
75740   int jresult ;
75741   int result;
75742
75743   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
75744   jresult = (int)result;
75745   return jresult;
75746 }
75747
75748
75749 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
75750   int jresult ;
75751   int result;
75752
75753   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
75754   jresult = (int)result;
75755   return jresult;
75756 }
75757
75758
75759 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
75760   int jresult ;
75761   int result;
75762
75763   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
75764   jresult = (int)result;
75765   return jresult;
75766 }
75767
75768
75769 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
75770   int jresult ;
75771   int result;
75772
75773   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
75774   jresult = (int)result;
75775   return jresult;
75776 }
75777
75778
75779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
75780   int jresult ;
75781   int result;
75782
75783   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
75784   jresult = (int)result;
75785   return jresult;
75786 }
75787
75788
75789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
75790   int jresult ;
75791   int result;
75792
75793   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
75794   jresult = (int)result;
75795   return jresult;
75796 }
75797
75798
75799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
75800   int jresult ;
75801   int result;
75802
75803   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
75804   jresult = (int)result;
75805   return jresult;
75806 }
75807
75808
75809 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
75810   int jresult ;
75811   int result;
75812
75813   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
75814   jresult = (int)result;
75815   return jresult;
75816 }
75817
75818
75819 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
75820   int jresult ;
75821   int result;
75822
75823   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
75824   jresult = (int)result;
75825   return jresult;
75826 }
75827
75828
75829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
75830   void * jresult ;
75831   Dali::Toolkit::ItemView::Property *result = 0 ;
75832
75833   {
75834     try {
75835       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
75836     } catch (std::out_of_range& e) {
75837       {
75838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75839       };
75840     } catch (std::exception& e) {
75841       {
75842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75843       };
75844     } catch (Dali::DaliException e) {
75845       {
75846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75847       };
75848     } catch (...) {
75849       {
75850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75851       };
75852     }
75853   }
75854
75855   jresult = (void *)result;
75856   return jresult;
75857 }
75858
75859
75860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
75861   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
75862
75863   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
75864   {
75865     try {
75866       delete arg1;
75867     } catch (std::out_of_range& e) {
75868       {
75869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75870       };
75871     } catch (std::exception& e) {
75872       {
75873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75874       };
75875     } catch (Dali::DaliException e) {
75876       {
75877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75878       };
75879     } catch (...) {
75880       {
75881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75882       };
75883     }
75884   }
75885
75886 }
75887
75888
75889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
75890   void * jresult ;
75891   Dali::Toolkit::ItemView *result = 0 ;
75892
75893   {
75894     try {
75895       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
75896     } catch (std::out_of_range& e) {
75897       {
75898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75899       };
75900     } catch (std::exception& e) {
75901       {
75902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75903       };
75904     } catch (Dali::DaliException e) {
75905       {
75906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75907       };
75908     } catch (...) {
75909       {
75910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75911       };
75912     }
75913   }
75914
75915   jresult = (void *)result;
75916   return jresult;
75917 }
75918
75919
75920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
75921   void * jresult ;
75922   Dali::Toolkit::ItemView *arg1 = 0 ;
75923   Dali::Toolkit::ItemView *result = 0 ;
75924
75925   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75926   if (!arg1) {
75927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
75928     return 0;
75929   }
75930   {
75931     try {
75932       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
75933     } catch (std::out_of_range& e) {
75934       {
75935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75936       };
75937     } catch (std::exception& e) {
75938       {
75939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75940       };
75941     } catch (Dali::DaliException e) {
75942       {
75943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75944       };
75945     } catch (...) {
75946       {
75947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75948       };
75949     }
75950   }
75951
75952   jresult = (void *)result;
75953   return jresult;
75954 }
75955
75956
75957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
75958   void * jresult ;
75959   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75960   Dali::Toolkit::ItemView *arg2 = 0 ;
75961   Dali::Toolkit::ItemView *result = 0 ;
75962
75963   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75964   arg2 = (Dali::Toolkit::ItemView *)jarg2;
75965   if (!arg2) {
75966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
75967     return 0;
75968   }
75969   {
75970     try {
75971       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
75972     } catch (std::out_of_range& e) {
75973       {
75974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75975       };
75976     } catch (std::exception& e) {
75977       {
75978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75979       };
75980     } catch (Dali::DaliException e) {
75981       {
75982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75983       };
75984     } catch (...) {
75985       {
75986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75987       };
75988     }
75989   }
75990
75991   jresult = (void *)result;
75992   return jresult;
75993 }
75994
75995
75996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
75997   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75998
75999   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76000   {
76001     try {
76002       delete arg1;
76003     } catch (std::out_of_range& e) {
76004       {
76005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76006       };
76007     } catch (std::exception& e) {
76008       {
76009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76010       };
76011     } catch (Dali::DaliException e) {
76012       {
76013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76014       };
76015     } catch (...) {
76016       {
76017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76018       };
76019     }
76020   }
76021
76022 }
76023
76024
76025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
76026   void * jresult ;
76027   Dali::Toolkit::ItemFactory *arg1 = 0 ;
76028   Dali::Toolkit::ItemView result;
76029
76030   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76031   if (!arg1) {
76032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
76033     return 0;
76034   }
76035   {
76036     try {
76037       result = Dali::Toolkit::ItemView::New(*arg1);
76038     } catch (std::out_of_range& e) {
76039       {
76040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76041       };
76042     } catch (std::exception& e) {
76043       {
76044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76045       };
76046     } catch (Dali::DaliException e) {
76047       {
76048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76049       };
76050     } catch (...) {
76051       {
76052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76053       };
76054     }
76055   }
76056
76057   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
76058   return jresult;
76059 }
76060
76061
76062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
76063   void * jresult ;
76064   Dali::BaseHandle arg1 ;
76065   Dali::BaseHandle *argp1 ;
76066   Dali::Toolkit::ItemView result;
76067
76068   argp1 = (Dali::BaseHandle *)jarg1;
76069   if (!argp1) {
76070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76071     return 0;
76072   }
76073   arg1 = *argp1;
76074   {
76075     try {
76076       result = Dali::Toolkit::ItemView::DownCast(arg1);
76077     } catch (std::out_of_range& e) {
76078       {
76079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76080       };
76081     } catch (std::exception& e) {
76082       {
76083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76084       };
76085     } catch (Dali::DaliException e) {
76086       {
76087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76088       };
76089     } catch (...) {
76090       {
76091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76092       };
76093     }
76094   }
76095
76096   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
76097   return jresult;
76098 }
76099
76100
76101 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
76102   unsigned int jresult ;
76103   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76104   unsigned int result;
76105
76106   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76107   {
76108     try {
76109       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
76110     } catch (std::out_of_range& e) {
76111       {
76112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76113       };
76114     } catch (std::exception& e) {
76115       {
76116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76117       };
76118     } catch (Dali::DaliException e) {
76119       {
76120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76121       };
76122     } catch (...) {
76123       {
76124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76125       };
76126     }
76127   }
76128
76129   jresult = result;
76130   return jresult;
76131 }
76132
76133
76134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
76135   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76136   Dali::Toolkit::ItemLayout *arg2 = 0 ;
76137
76138   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76139   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
76140   if (!arg2) {
76141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
76142     return ;
76143   }
76144   {
76145     try {
76146       (arg1)->AddLayout(*arg2);
76147     } catch (std::out_of_range& e) {
76148       {
76149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76150       };
76151     } catch (std::exception& e) {
76152       {
76153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76154       };
76155     } catch (Dali::DaliException e) {
76156       {
76157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76158       };
76159     } catch (...) {
76160       {
76161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76162       };
76163     }
76164   }
76165
76166 }
76167
76168
76169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
76170   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76171   unsigned int arg2 ;
76172
76173   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76174   arg2 = (unsigned int)jarg2;
76175   {
76176     try {
76177       (arg1)->RemoveLayout(arg2);
76178     } catch (std::out_of_range& e) {
76179       {
76180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76181       };
76182     } catch (std::exception& e) {
76183       {
76184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76185       };
76186     } catch (Dali::DaliException e) {
76187       {
76188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76189       };
76190     } catch (...) {
76191       {
76192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76193       };
76194     }
76195   }
76196
76197 }
76198
76199
76200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
76201   void * jresult ;
76202   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76203   unsigned int arg2 ;
76204   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76205
76206   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76207   arg2 = (unsigned int)jarg2;
76208   {
76209     try {
76210       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
76211     } catch (std::out_of_range& e) {
76212       {
76213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76214       };
76215     } catch (std::exception& e) {
76216       {
76217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76218       };
76219     } catch (Dali::DaliException e) {
76220       {
76221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76222       };
76223     } catch (...) {
76224       {
76225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76226       };
76227     }
76228   }
76229
76230   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76231   return jresult;
76232 }
76233
76234
76235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
76236   void * jresult ;
76237   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76238   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76239
76240   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76241   {
76242     try {
76243       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
76244     } catch (std::out_of_range& e) {
76245       {
76246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76247       };
76248     } catch (std::exception& e) {
76249       {
76250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76251       };
76252     } catch (Dali::DaliException e) {
76253       {
76254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76255       };
76256     } catch (...) {
76257       {
76258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76259       };
76260     }
76261   }
76262
76263   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76264   return jresult;
76265 }
76266
76267
76268 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
76269   float jresult ;
76270   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76271   Dali::Toolkit::ItemId arg2 ;
76272   float result;
76273
76274   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76275   arg2 = (Dali::Toolkit::ItemId)jarg2;
76276   {
76277     try {
76278       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
76279     } catch (std::out_of_range& e) {
76280       {
76281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76282       };
76283     } catch (std::exception& e) {
76284       {
76285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76286       };
76287     } catch (Dali::DaliException e) {
76288       {
76289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76290       };
76291     } catch (...) {
76292       {
76293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76294       };
76295     }
76296   }
76297
76298   jresult = result;
76299   return jresult;
76300 }
76301
76302
76303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
76304   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76305   unsigned int arg2 ;
76306   Dali::Vector3 arg3 ;
76307   float arg4 ;
76308   Dali::Vector3 *argp3 ;
76309
76310   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76311   arg2 = (unsigned int)jarg2;
76312   argp3 = (Dali::Vector3 *)jarg3;
76313   if (!argp3) {
76314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
76315     return ;
76316   }
76317   arg3 = *argp3;
76318   arg4 = (float)jarg4;
76319   {
76320     try {
76321       (arg1)->ActivateLayout(arg2,arg3,arg4);
76322     } catch (std::out_of_range& e) {
76323       {
76324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76325       };
76326     } catch (std::exception& e) {
76327       {
76328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76329       };
76330     } catch (Dali::DaliException e) {
76331       {
76332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76333       };
76334     } catch (...) {
76335       {
76336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76337       };
76338     }
76339   }
76340
76341 }
76342
76343
76344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
76345   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76346
76347   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76348   {
76349     try {
76350       (arg1)->DeactivateCurrentLayout();
76351     } catch (std::out_of_range& e) {
76352       {
76353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76354       };
76355     } catch (std::exception& e) {
76356       {
76357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76358       };
76359     } catch (Dali::DaliException e) {
76360       {
76361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76362       };
76363     } catch (...) {
76364       {
76365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76366       };
76367     }
76368   }
76369
76370 }
76371
76372
76373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
76374   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76375   float arg2 ;
76376
76377   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76378   arg2 = (float)jarg2;
76379   {
76380     try {
76381       (arg1)->SetMinimumSwipeSpeed(arg2);
76382     } catch (std::out_of_range& e) {
76383       {
76384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76385       };
76386     } catch (std::exception& e) {
76387       {
76388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76389       };
76390     } catch (Dali::DaliException e) {
76391       {
76392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76393       };
76394     } catch (...) {
76395       {
76396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76397       };
76398     }
76399   }
76400
76401 }
76402
76403
76404 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
76405   float jresult ;
76406   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76407   float result;
76408
76409   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76410   {
76411     try {
76412       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
76413     } catch (std::out_of_range& e) {
76414       {
76415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76416       };
76417     } catch (std::exception& e) {
76418       {
76419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76420       };
76421     } catch (Dali::DaliException e) {
76422       {
76423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76424       };
76425     } catch (...) {
76426       {
76427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76428       };
76429     }
76430   }
76431
76432   jresult = result;
76433   return jresult;
76434 }
76435
76436
76437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
76438   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76439   float arg2 ;
76440
76441   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76442   arg2 = (float)jarg2;
76443   {
76444     try {
76445       (arg1)->SetMinimumSwipeDistance(arg2);
76446     } catch (std::out_of_range& e) {
76447       {
76448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76449       };
76450     } catch (std::exception& e) {
76451       {
76452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76453       };
76454     } catch (Dali::DaliException e) {
76455       {
76456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76457       };
76458     } catch (...) {
76459       {
76460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76461       };
76462     }
76463   }
76464
76465 }
76466
76467
76468 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
76469   float jresult ;
76470   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76471   float result;
76472
76473   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76474   {
76475     try {
76476       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
76477     } catch (std::out_of_range& e) {
76478       {
76479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76480       };
76481     } catch (std::exception& e) {
76482       {
76483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76484       };
76485     } catch (Dali::DaliException e) {
76486       {
76487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76488       };
76489     } catch (...) {
76490       {
76491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76492       };
76493     }
76494   }
76495
76496   jresult = result;
76497   return jresult;
76498 }
76499
76500
76501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
76502   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76503   float arg2 ;
76504
76505   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76506   arg2 = (float)jarg2;
76507   {
76508     try {
76509       (arg1)->SetWheelScrollDistanceStep(arg2);
76510     } catch (std::out_of_range& e) {
76511       {
76512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76513       };
76514     } catch (std::exception& e) {
76515       {
76516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76517       };
76518     } catch (Dali::DaliException e) {
76519       {
76520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76521       };
76522     } catch (...) {
76523       {
76524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76525       };
76526     }
76527   }
76528
76529 }
76530
76531
76532 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
76533   float jresult ;
76534   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76535   float result;
76536
76537   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76538   {
76539     try {
76540       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
76541     } catch (std::out_of_range& e) {
76542       {
76543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76544       };
76545     } catch (std::exception& e) {
76546       {
76547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76548       };
76549     } catch (Dali::DaliException e) {
76550       {
76551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76552       };
76553     } catch (...) {
76554       {
76555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76556       };
76557     }
76558   }
76559
76560   jresult = result;
76561   return jresult;
76562 }
76563
76564
76565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
76566   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76567   bool arg2 ;
76568
76569   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76570   arg2 = jarg2 ? true : false;
76571   {
76572     try {
76573       (arg1)->SetAnchoring(arg2);
76574     } catch (std::out_of_range& e) {
76575       {
76576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76577       };
76578     } catch (std::exception& e) {
76579       {
76580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76581       };
76582     } catch (Dali::DaliException e) {
76583       {
76584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76585       };
76586     } catch (...) {
76587       {
76588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76589       };
76590     }
76591   }
76592
76593 }
76594
76595 //// ========================= end of part 3 =============================
76596
76597 //// ========================== start part 4 ===============================
76598
76599
76600 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
76601   unsigned int jresult ;
76602   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76603   bool result;
76604
76605   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76606   {
76607     try {
76608       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
76609     } catch (std::out_of_range& e) {
76610       {
76611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76612       };
76613     } catch (std::exception& e) {
76614       {
76615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76616       };
76617     } catch (Dali::DaliException e) {
76618       {
76619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76620       };
76621     } catch (...) {
76622       {
76623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76624       };
76625     }
76626   }
76627
76628   jresult = result;
76629   return jresult;
76630 }
76631
76632
76633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
76634   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76635   float arg2 ;
76636
76637   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76638   arg2 = (float)jarg2;
76639   {
76640     try {
76641       (arg1)->SetAnchoringDuration(arg2);
76642     } catch (std::out_of_range& e) {
76643       {
76644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76645       };
76646     } catch (std::exception& e) {
76647       {
76648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76649       };
76650     } catch (Dali::DaliException e) {
76651       {
76652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76653       };
76654     } catch (...) {
76655       {
76656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76657       };
76658     }
76659   }
76660
76661 }
76662
76663
76664 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
76665   float jresult ;
76666   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76667   float result;
76668
76669   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76670   {
76671     try {
76672       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
76673     } catch (std::out_of_range& e) {
76674       {
76675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76676       };
76677     } catch (std::exception& e) {
76678       {
76679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76680       };
76681     } catch (Dali::DaliException e) {
76682       {
76683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76684       };
76685     } catch (...) {
76686       {
76687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76688       };
76689     }
76690   }
76691
76692   jresult = result;
76693   return jresult;
76694 }
76695
76696
76697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
76698   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76699   Dali::Toolkit::ItemId arg2 ;
76700   float arg3 ;
76701
76702   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76703   arg2 = (Dali::Toolkit::ItemId)jarg2;
76704   arg3 = (float)jarg3;
76705   {
76706     try {
76707       (arg1)->ScrollToItem(arg2,arg3);
76708     } catch (std::out_of_range& e) {
76709       {
76710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76711       };
76712     } catch (std::exception& e) {
76713       {
76714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76715       };
76716     } catch (Dali::DaliException e) {
76717       {
76718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76719       };
76720     } catch (...) {
76721       {
76722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76723       };
76724     }
76725   }
76726
76727 }
76728
76729
76730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
76731   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76732   float arg2 ;
76733
76734   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76735   arg2 = (float)jarg2;
76736   {
76737     try {
76738       (arg1)->SetRefreshInterval(arg2);
76739     } catch (std::out_of_range& e) {
76740       {
76741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76742       };
76743     } catch (std::exception& e) {
76744       {
76745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76746       };
76747     } catch (Dali::DaliException e) {
76748       {
76749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76750       };
76751     } catch (...) {
76752       {
76753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76754       };
76755     }
76756   }
76757
76758 }
76759
76760
76761 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
76762   float jresult ;
76763   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76764   float result;
76765
76766   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76767   {
76768     try {
76769       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
76770     } catch (std::out_of_range& e) {
76771       {
76772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76773       };
76774     } catch (std::exception& e) {
76775       {
76776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76777       };
76778     } catch (Dali::DaliException e) {
76779       {
76780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76781       };
76782     } catch (...) {
76783       {
76784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76785       };
76786     }
76787   }
76788
76789   jresult = result;
76790   return jresult;
76791 }
76792
76793
76794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
76795   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76796
76797   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76798   {
76799     try {
76800       (arg1)->Refresh();
76801     } catch (std::out_of_range& e) {
76802       {
76803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76804       };
76805     } catch (std::exception& e) {
76806       {
76807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76808       };
76809     } catch (Dali::DaliException e) {
76810       {
76811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76812       };
76813     } catch (...) {
76814       {
76815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76816       };
76817     }
76818   }
76819
76820 }
76821
76822
76823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
76824   void * jresult ;
76825   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76826   Dali::Toolkit::ItemId arg2 ;
76827   Dali::Actor result;
76828
76829   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76830   arg2 = (Dali::Toolkit::ItemId)jarg2;
76831   {
76832     try {
76833       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
76834     } catch (std::out_of_range& e) {
76835       {
76836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76837       };
76838     } catch (std::exception& e) {
76839       {
76840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76841       };
76842     } catch (Dali::DaliException e) {
76843       {
76844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76845       };
76846     } catch (...) {
76847       {
76848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76849       };
76850     }
76851   }
76852
76853   jresult = new Dali::Actor((const Dali::Actor &)result);
76854   return jresult;
76855 }
76856
76857
76858 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
76859   unsigned int jresult ;
76860   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76861   Dali::Actor arg2 ;
76862   Dali::Actor *argp2 ;
76863   Dali::Toolkit::ItemId result;
76864
76865   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76866   argp2 = (Dali::Actor *)jarg2;
76867   if (!argp2) {
76868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76869     return 0;
76870   }
76871   arg2 = *argp2;
76872   {
76873     try {
76874       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
76875     } catch (std::out_of_range& e) {
76876       {
76877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76878       };
76879     } catch (std::exception& e) {
76880       {
76881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76882       };
76883     } catch (Dali::DaliException e) {
76884       {
76885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76886       };
76887     } catch (...) {
76888       {
76889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76890       };
76891     }
76892   }
76893
76894   jresult = result;
76895   return jresult;
76896 }
76897
76898
76899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
76900   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76901   Dali::Toolkit::Item arg2 ;
76902   float arg3 ;
76903   Dali::Toolkit::Item *argp2 ;
76904
76905   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76906   argp2 = (Dali::Toolkit::Item *)jarg2;
76907   if (!argp2) {
76908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
76909     return ;
76910   }
76911   arg2 = *argp2;
76912   arg3 = (float)jarg3;
76913   {
76914     try {
76915       (arg1)->InsertItem(arg2,arg3);
76916     } catch (std::out_of_range& e) {
76917       {
76918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76919       };
76920     } catch (std::exception& e) {
76921       {
76922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76923       };
76924     } catch (Dali::DaliException e) {
76925       {
76926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76927       };
76928     } catch (...) {
76929       {
76930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76931       };
76932     }
76933   }
76934
76935 }
76936
76937
76938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
76939   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76940   Dali::Toolkit::ItemContainer *arg2 = 0 ;
76941   float arg3 ;
76942
76943   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76944   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
76945   if (!arg2) {
76946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
76947     return ;
76948   }
76949   arg3 = (float)jarg3;
76950   {
76951     try {
76952       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
76953     } catch (std::out_of_range& e) {
76954       {
76955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76956       };
76957     } catch (std::exception& e) {
76958       {
76959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76960       };
76961     } catch (Dali::DaliException e) {
76962       {
76963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76964       };
76965     } catch (...) {
76966       {
76967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76968       };
76969     }
76970   }
76971
76972 }
76973
76974
76975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
76976   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76977   Dali::Toolkit::ItemId arg2 ;
76978   float arg3 ;
76979
76980   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76981   arg2 = (Dali::Toolkit::ItemId)jarg2;
76982   arg3 = (float)jarg3;
76983   {
76984     try {
76985       (arg1)->RemoveItem(arg2,arg3);
76986     } catch (std::out_of_range& e) {
76987       {
76988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76989       };
76990     } catch (std::exception& e) {
76991       {
76992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76993       };
76994     } catch (Dali::DaliException e) {
76995       {
76996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76997       };
76998     } catch (...) {
76999       {
77000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77001       };
77002     }
77003   }
77004
77005 }
77006
77007
77008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
77009   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77010   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
77011   float arg3 ;
77012
77013   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77014   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
77015   if (!arg2) {
77016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
77017     return ;
77018   }
77019   arg3 = (float)jarg3;
77020   {
77021     try {
77022       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
77023     } catch (std::out_of_range& e) {
77024       {
77025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77026       };
77027     } catch (std::exception& e) {
77028       {
77029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77030       };
77031     } catch (Dali::DaliException e) {
77032       {
77033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77034       };
77035     } catch (...) {
77036       {
77037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77038       };
77039     }
77040   }
77041
77042 }
77043
77044
77045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
77046   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77047   Dali::Toolkit::Item arg2 ;
77048   float arg3 ;
77049   Dali::Toolkit::Item *argp2 ;
77050
77051   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77052   argp2 = (Dali::Toolkit::Item *)jarg2;
77053   if (!argp2) {
77054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
77055     return ;
77056   }
77057   arg2 = *argp2;
77058   arg3 = (float)jarg3;
77059   {
77060     try {
77061       (arg1)->ReplaceItem(arg2,arg3);
77062     } catch (std::out_of_range& e) {
77063       {
77064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77065       };
77066     } catch (std::exception& e) {
77067       {
77068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77069       };
77070     } catch (Dali::DaliException e) {
77071       {
77072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77073       };
77074     } catch (...) {
77075       {
77076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77077       };
77078     }
77079   }
77080
77081 }
77082
77083
77084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
77085   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77086   Dali::Toolkit::ItemContainer *arg2 = 0 ;
77087   float arg3 ;
77088
77089   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77090   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
77091   if (!arg2) {
77092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
77093     return ;
77094   }
77095   arg3 = (float)jarg3;
77096   {
77097     try {
77098       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
77099     } catch (std::out_of_range& e) {
77100       {
77101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77102       };
77103     } catch (std::exception& e) {
77104       {
77105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77106       };
77107     } catch (Dali::DaliException e) {
77108       {
77109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77110       };
77111     } catch (...) {
77112       {
77113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77114       };
77115     }
77116   }
77117
77118 }
77119
77120
77121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
77122   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77123   Dali::Vector3 *arg2 = 0 ;
77124
77125   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77126   arg2 = (Dali::Vector3 *)jarg2;
77127   if (!arg2) {
77128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77129     return ;
77130   }
77131   {
77132     try {
77133       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
77134     } catch (std::out_of_range& e) {
77135       {
77136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77137       };
77138     } catch (std::exception& e) {
77139       {
77140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77141       };
77142     } catch (Dali::DaliException e) {
77143       {
77144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77145       };
77146     } catch (...) {
77147       {
77148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77149       };
77150     }
77151   }
77152
77153 }
77154
77155
77156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
77157   void * jresult ;
77158   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77159   Dali::Vector3 result;
77160
77161   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77162   {
77163     try {
77164       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
77165     } catch (std::out_of_range& e) {
77166       {
77167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77168       };
77169     } catch (std::exception& e) {
77170       {
77171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77172       };
77173     } catch (Dali::DaliException e) {
77174       {
77175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77176       };
77177     } catch (...) {
77178       {
77179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77180       };
77181     }
77182   }
77183
77184   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77185   return jresult;
77186 }
77187
77188
77189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
77190   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77191   Dali::Vector3 *arg2 = 0 ;
77192
77193   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77194   arg2 = (Dali::Vector3 *)jarg2;
77195   if (!arg2) {
77196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77197     return ;
77198   }
77199   {
77200     try {
77201       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
77202     } catch (std::out_of_range& e) {
77203       {
77204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77205       };
77206     } catch (std::exception& e) {
77207       {
77208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77209       };
77210     } catch (Dali::DaliException e) {
77211       {
77212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77213       };
77214     } catch (...) {
77215       {
77216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77217       };
77218     }
77219   }
77220
77221 }
77222
77223
77224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
77225   void * jresult ;
77226   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77227   Dali::Vector3 result;
77228
77229   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77230   {
77231     try {
77232       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
77233     } catch (std::out_of_range& e) {
77234       {
77235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77236       };
77237     } catch (std::exception& e) {
77238       {
77239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77240       };
77241     } catch (Dali::DaliException e) {
77242       {
77243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77244       };
77245     } catch (...) {
77246       {
77247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77248       };
77249     }
77250   }
77251
77252   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77253   return jresult;
77254 }
77255
77256
77257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
77258   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77259   Dali::Toolkit::ItemRange *arg2 = 0 ;
77260
77261   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77262   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
77263   if (!arg2) {
77264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
77265     return ;
77266   }
77267   {
77268     try {
77269       (arg1)->GetItemsRange(*arg2);
77270     } catch (std::out_of_range& e) {
77271       {
77272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77273       };
77274     } catch (std::exception& e) {
77275       {
77276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77277       };
77278     } catch (Dali::DaliException e) {
77279       {
77280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77281       };
77282     } catch (...) {
77283       {
77284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77285       };
77286     }
77287   }
77288
77289 }
77290
77291
77292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
77293   void * jresult ;
77294   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77295   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
77296
77297   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77298   {
77299     try {
77300       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
77301     } catch (std::out_of_range& e) {
77302       {
77303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77304       };
77305     } catch (std::exception& e) {
77306       {
77307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77308       };
77309     } catch (Dali::DaliException e) {
77310       {
77311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77312       };
77313     } catch (...) {
77314       {
77315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77316       };
77317     }
77318   }
77319
77320   jresult = (void *)result;
77321   return jresult;
77322 }
77323
77324
77325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
77326   Dali::Vector3 *arg1 = 0 ;
77327   PropertyInputContainer *arg2 = 0 ;
77328
77329   arg1 = (Dali::Vector3 *)jarg1;
77330   if (!arg1) {
77331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77332     return ;
77333   }
77334   arg2 = (PropertyInputContainer *)jarg2;
77335   if (!arg2) {
77336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77337     return ;
77338   }
77339   {
77340     try {
77341       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77342     } catch (std::out_of_range& e) {
77343       {
77344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77345       };
77346     } catch (std::exception& e) {
77347       {
77348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77349       };
77350     } catch (Dali::DaliException e) {
77351       {
77352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77353       };
77354     } catch (...) {
77355       {
77356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77357       };
77358     }
77359   }
77360
77361 }
77362
77363
77364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
77365   Dali::Vector3 *arg1 = 0 ;
77366   PropertyInputContainer *arg2 = 0 ;
77367
77368   arg1 = (Dali::Vector3 *)jarg1;
77369   if (!arg1) {
77370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77371     return ;
77372   }
77373   arg2 = (PropertyInputContainer *)jarg2;
77374   if (!arg2) {
77375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77376     return ;
77377   }
77378   {
77379     try {
77380       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77381     } catch (std::out_of_range& e) {
77382       {
77383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77384       };
77385     } catch (std::exception& e) {
77386       {
77387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77388       };
77389     } catch (Dali::DaliException e) {
77390       {
77391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77392       };
77393     } catch (...) {
77394       {
77395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77396       };
77397     }
77398   }
77399
77400 }
77401
77402
77403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
77404   void * jresult ;
77405   Dali::Toolkit::ScrollViewEffect *result = 0 ;
77406
77407   {
77408     try {
77409       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
77410     } catch (std::out_of_range& e) {
77411       {
77412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77413       };
77414     } catch (std::exception& e) {
77415       {
77416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77417       };
77418     } catch (Dali::DaliException e) {
77419       {
77420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77421       };
77422     } catch (...) {
77423       {
77424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77425       };
77426     }
77427   }
77428
77429   jresult = (void *)result;
77430   return jresult;
77431 }
77432
77433
77434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
77435   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
77436
77437   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
77438   {
77439     try {
77440       delete arg1;
77441     } catch (std::out_of_range& e) {
77442       {
77443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77444       };
77445     } catch (std::exception& e) {
77446       {
77447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77448       };
77449     } catch (Dali::DaliException e) {
77450       {
77451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77452       };
77453     } catch (...) {
77454       {
77455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77456       };
77457     }
77458   }
77459
77460 }
77461
77462
77463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
77464   void * jresult ;
77465   Dali::Path arg1 ;
77466   Dali::Vector3 *arg2 = 0 ;
77467   Dali::Property::Index arg3 ;
77468   Dali::Vector3 *arg4 = 0 ;
77469   unsigned int arg5 ;
77470   Dali::Path *argp1 ;
77471   Dali::Toolkit::ScrollViewPagePathEffect result;
77472
77473   argp1 = (Dali::Path *)jarg1;
77474   if (!argp1) {
77475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
77476     return 0;
77477   }
77478   arg1 = *argp1;
77479   arg2 = (Dali::Vector3 *)jarg2;
77480   if (!arg2) {
77481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77482     return 0;
77483   }
77484   arg3 = (Dali::Property::Index)jarg3;
77485   arg4 = (Dali::Vector3 *)jarg4;
77486   if (!arg4) {
77487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77488     return 0;
77489   }
77490   arg5 = (unsigned int)jarg5;
77491   {
77492     try {
77493       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
77494     } catch (std::out_of_range& e) {
77495       {
77496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77497       };
77498     } catch (std::exception& e) {
77499       {
77500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77501       };
77502     } catch (Dali::DaliException e) {
77503       {
77504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77505       };
77506     } catch (...) {
77507       {
77508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77509       };
77510     }
77511   }
77512
77513   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77514   return jresult;
77515 }
77516
77517
77518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
77519   void * jresult ;
77520   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
77521
77522   {
77523     try {
77524       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
77525     } catch (std::out_of_range& e) {
77526       {
77527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77528       };
77529     } catch (std::exception& e) {
77530       {
77531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77532       };
77533     } catch (Dali::DaliException e) {
77534       {
77535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77536       };
77537     } catch (...) {
77538       {
77539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77540       };
77541     }
77542   }
77543
77544   jresult = (void *)result;
77545   return jresult;
77546 }
77547
77548
77549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
77550   void * jresult ;
77551   Dali::BaseHandle arg1 ;
77552   Dali::BaseHandle *argp1 ;
77553   Dali::Toolkit::ScrollViewPagePathEffect result;
77554
77555   argp1 = (Dali::BaseHandle *)jarg1;
77556   if (!argp1) {
77557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77558     return 0;
77559   }
77560   arg1 = *argp1;
77561   {
77562     try {
77563       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
77564     } catch (std::out_of_range& e) {
77565       {
77566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77567       };
77568     } catch (std::exception& e) {
77569       {
77570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77571       };
77572     } catch (Dali::DaliException e) {
77573       {
77574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77575       };
77576     } catch (...) {
77577       {
77578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77579       };
77580     }
77581   }
77582
77583   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77584   return jresult;
77585 }
77586
77587
77588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
77589   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
77590   Dali::Actor arg2 ;
77591   unsigned int arg3 ;
77592   Dali::Actor *argp2 ;
77593
77594   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
77595   argp2 = (Dali::Actor *)jarg2;
77596   if (!argp2) {
77597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77598     return ;
77599   }
77600   arg2 = *argp2;
77601   arg3 = (unsigned int)jarg3;
77602   {
77603     try {
77604       (arg1)->ApplyToPage(arg2,arg3);
77605     } catch (std::out_of_range& e) {
77606       {
77607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77608       };
77609     } catch (std::exception& e) {
77610       {
77611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77612       };
77613     } catch (Dali::DaliException e) {
77614       {
77615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77616       };
77617     } catch (...) {
77618       {
77619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77620       };
77621     }
77622   }
77623
77624 }
77625
77626
77627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
77628   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
77629
77630   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
77631   {
77632     try {
77633       delete arg1;
77634     } catch (std::out_of_range& e) {
77635       {
77636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77637       };
77638     } catch (std::exception& e) {
77639       {
77640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77641       };
77642     } catch (Dali::DaliException e) {
77643       {
77644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77645       };
77646     } catch (...) {
77647       {
77648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77649       };
77650     }
77651   }
77652
77653 }
77654
77655
77656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
77657   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77658   Dali::Toolkit::ClampState arg2 ;
77659
77660   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77661   arg2 = (Dali::Toolkit::ClampState)jarg2;
77662   if (arg1) (arg1)->x = arg2;
77663 }
77664
77665
77666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
77667   int jresult ;
77668   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77669   Dali::Toolkit::ClampState result;
77670
77671   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77672   result = (Dali::Toolkit::ClampState) ((arg1)->x);
77673   jresult = (int)result;
77674   return jresult;
77675 }
77676
77677
77678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
77679   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77680   Dali::Toolkit::ClampState arg2 ;
77681
77682   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77683   arg2 = (Dali::Toolkit::ClampState)jarg2;
77684   if (arg1) (arg1)->y = arg2;
77685 }
77686
77687
77688 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
77689   int jresult ;
77690   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77691   Dali::Toolkit::ClampState result;
77692
77693   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77694   result = (Dali::Toolkit::ClampState) ((arg1)->y);
77695   jresult = (int)result;
77696   return jresult;
77697 }
77698
77699
77700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
77701   void * jresult ;
77702   Dali::Toolkit::ClampState2D *result = 0 ;
77703
77704   {
77705     try {
77706       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
77707     } catch (std::out_of_range& e) {
77708       {
77709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77710       };
77711     } catch (std::exception& e) {
77712       {
77713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77714       };
77715     } catch (Dali::DaliException e) {
77716       {
77717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77718       };
77719     } catch (...) {
77720       {
77721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77722       };
77723     }
77724   }
77725
77726   jresult = (void *)result;
77727   return jresult;
77728 }
77729
77730
77731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
77732   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77733
77734   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77735   {
77736     try {
77737       delete arg1;
77738     } catch (std::out_of_range& e) {
77739       {
77740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77741       };
77742     } catch (std::exception& e) {
77743       {
77744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77745       };
77746     } catch (Dali::DaliException e) {
77747       {
77748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77749       };
77750     } catch (...) {
77751       {
77752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77753       };
77754     }
77755   }
77756
77757 }
77758
77759
77760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
77761   void * jresult ;
77762   float arg1 ;
77763   float arg2 ;
77764   bool arg3 ;
77765   Dali::Toolkit::RulerDomain *result = 0 ;
77766
77767   arg1 = (float)jarg1;
77768   arg2 = (float)jarg2;
77769   arg3 = jarg3 ? true : false;
77770   {
77771     try {
77772       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
77773     } catch (std::out_of_range& e) {
77774       {
77775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77776       };
77777     } catch (std::exception& e) {
77778       {
77779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77780       };
77781     } catch (Dali::DaliException e) {
77782       {
77783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77784       };
77785     } catch (...) {
77786       {
77787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77788       };
77789     }
77790   }
77791
77792   jresult = (void *)result;
77793   return jresult;
77794 }
77795
77796
77797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
77798   void * jresult ;
77799   float arg1 ;
77800   float arg2 ;
77801   Dali::Toolkit::RulerDomain *result = 0 ;
77802
77803   arg1 = (float)jarg1;
77804   arg2 = (float)jarg2;
77805   {
77806     try {
77807       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
77808     } catch (std::out_of_range& e) {
77809       {
77810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77811       };
77812     } catch (std::exception& e) {
77813       {
77814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77815       };
77816     } catch (Dali::DaliException e) {
77817       {
77818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77819       };
77820     } catch (...) {
77821       {
77822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77823       };
77824     }
77825   }
77826
77827   jresult = (void *)result;
77828   return jresult;
77829 }
77830
77831
77832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
77833   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77834   float arg2 ;
77835
77836   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77837   arg2 = (float)jarg2;
77838   if (arg1) (arg1)->min = arg2;
77839 }
77840
77841
77842 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
77843   float jresult ;
77844   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77845   float result;
77846
77847   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77848   result = (float) ((arg1)->min);
77849   jresult = result;
77850   return jresult;
77851 }
77852
77853
77854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
77855   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77856   float arg2 ;
77857
77858   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77859   arg2 = (float)jarg2;
77860   if (arg1) (arg1)->max = arg2;
77861 }
77862
77863
77864 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
77865   float jresult ;
77866   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77867   float result;
77868
77869   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77870   result = (float) ((arg1)->max);
77871   jresult = result;
77872   return jresult;
77873 }
77874
77875
77876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
77877   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77878   bool arg2 ;
77879
77880   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77881   arg2 = jarg2 ? true : false;
77882   if (arg1) (arg1)->enabled = arg2;
77883 }
77884
77885
77886 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
77887   unsigned int jresult ;
77888   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77889   bool result;
77890
77891   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77892   result = (bool) ((arg1)->enabled);
77893   jresult = result;
77894   return jresult;
77895 }
77896
77897
77898 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
77899   float jresult ;
77900   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77901   float arg2 ;
77902   float arg3 ;
77903   float arg4 ;
77904   float result;
77905
77906   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77907   arg2 = (float)jarg2;
77908   arg3 = (float)jarg3;
77909   arg4 = (float)jarg4;
77910   {
77911     try {
77912       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
77913     } catch (std::out_of_range& e) {
77914       {
77915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77916       };
77917     } catch (std::exception& e) {
77918       {
77919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77920       };
77921     } catch (Dali::DaliException e) {
77922       {
77923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77924       };
77925     } catch (...) {
77926       {
77927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77928       };
77929     }
77930   }
77931
77932   jresult = result;
77933   return jresult;
77934 }
77935
77936
77937 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
77938   float jresult ;
77939   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77940   float arg2 ;
77941   float arg3 ;
77942   float result;
77943
77944   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77945   arg2 = (float)jarg2;
77946   arg3 = (float)jarg3;
77947   {
77948     try {
77949       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
77950     } catch (std::out_of_range& e) {
77951       {
77952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77953       };
77954     } catch (std::exception& e) {
77955       {
77956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77957       };
77958     } catch (Dali::DaliException e) {
77959       {
77960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77961       };
77962     } catch (...) {
77963       {
77964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77965       };
77966     }
77967   }
77968
77969   jresult = result;
77970   return jresult;
77971 }
77972
77973
77974 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
77975   float jresult ;
77976   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77977   float arg2 ;
77978   float result;
77979
77980   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77981   arg2 = (float)jarg2;
77982   {
77983     try {
77984       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
77985     } catch (std::out_of_range& e) {
77986       {
77987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77988       };
77989     } catch (std::exception& e) {
77990       {
77991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77992       };
77993     } catch (Dali::DaliException e) {
77994       {
77995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77996       };
77997     } catch (...) {
77998       {
77999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78000       };
78001     }
78002   }
78003
78004   jresult = result;
78005   return jresult;
78006 }
78007
78008
78009 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
78010   float jresult ;
78011   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78012   float arg2 ;
78013   float arg3 ;
78014   float arg4 ;
78015   Dali::Toolkit::ClampState *arg5 = 0 ;
78016   float result;
78017
78018   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78019   arg2 = (float)jarg2;
78020   arg3 = (float)jarg3;
78021   arg4 = (float)jarg4;
78022   arg5 = (Dali::Toolkit::ClampState *)jarg5;
78023   if (!arg5) {
78024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78025     return 0;
78026   }
78027   {
78028     try {
78029       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
78030     } catch (std::out_of_range& e) {
78031       {
78032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78033       };
78034     } catch (std::exception& e) {
78035       {
78036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78037       };
78038     } catch (Dali::DaliException e) {
78039       {
78040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78041       };
78042     } catch (...) {
78043       {
78044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78045       };
78046     }
78047   }
78048
78049   jresult = result;
78050   return jresult;
78051 }
78052
78053
78054 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
78055   float jresult ;
78056   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78057   float result;
78058
78059   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78060   {
78061     try {
78062       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
78063     } catch (std::out_of_range& e) {
78064       {
78065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78066       };
78067     } catch (std::exception& e) {
78068       {
78069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78070       };
78071     } catch (Dali::DaliException e) {
78072       {
78073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78074       };
78075     } catch (...) {
78076       {
78077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78078       };
78079     }
78080   }
78081
78082   jresult = result;
78083   return jresult;
78084 }
78085
78086
78087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
78088   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78089
78090   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78091   {
78092     try {
78093       delete arg1;
78094     } catch (std::out_of_range& e) {
78095       {
78096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78097       };
78098     } catch (std::exception& e) {
78099       {
78100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78101       };
78102     } catch (Dali::DaliException e) {
78103       {
78104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78105       };
78106     } catch (...) {
78107       {
78108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78109       };
78110     }
78111   }
78112
78113 }
78114
78115
78116 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
78117   float jresult ;
78118   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78119   float arg2 ;
78120   float arg3 ;
78121   float result;
78122
78123   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78124   arg2 = (float)jarg2;
78125   arg3 = (float)jarg3;
78126   {
78127     try {
78128       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
78129     } catch (std::out_of_range& e) {
78130       {
78131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78132       };
78133     } catch (std::exception& e) {
78134       {
78135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78136       };
78137     } catch (Dali::DaliException e) {
78138       {
78139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78140       };
78141     } catch (...) {
78142       {
78143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78144       };
78145     }
78146   }
78147
78148   jresult = result;
78149   return jresult;
78150 }
78151
78152
78153 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
78154   float jresult ;
78155   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78156   float arg2 ;
78157   float result;
78158
78159   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78160   arg2 = (float)jarg2;
78161   {
78162     try {
78163       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
78164     } catch (std::out_of_range& e) {
78165       {
78166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78167       };
78168     } catch (std::exception& e) {
78169       {
78170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78171       };
78172     } catch (Dali::DaliException e) {
78173       {
78174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78175       };
78176     } catch (...) {
78177       {
78178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78179       };
78180     }
78181   }
78182
78183   jresult = result;
78184   return jresult;
78185 }
78186
78187
78188 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78189   float jresult ;
78190   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78191   unsigned int arg2 ;
78192   unsigned int *arg3 = 0 ;
78193   bool arg4 ;
78194   float result;
78195
78196   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78197   arg2 = (unsigned int)jarg2;
78198   arg3 = (unsigned int *)jarg3;
78199   arg4 = jarg4 ? true : false;
78200   {
78201     try {
78202       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78203     } catch (std::out_of_range& e) {
78204       {
78205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78206       };
78207     } catch (std::exception& e) {
78208       {
78209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78210       };
78211     } catch (Dali::DaliException e) {
78212       {
78213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78214       };
78215     } catch (...) {
78216       {
78217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78218       };
78219     }
78220   }
78221
78222   jresult = result;
78223   return jresult;
78224 }
78225
78226
78227 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78228   unsigned int jresult ;
78229   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78230   float arg2 ;
78231   bool arg3 ;
78232   unsigned int result;
78233
78234   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78235   arg2 = (float)jarg2;
78236   arg3 = jarg3 ? true : false;
78237   {
78238     try {
78239       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
78240     } catch (std::out_of_range& e) {
78241       {
78242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78243       };
78244     } catch (std::exception& e) {
78245       {
78246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78247       };
78248     } catch (Dali::DaliException e) {
78249       {
78250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78251       };
78252     } catch (...) {
78253       {
78254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78255       };
78256     }
78257   }
78258
78259   jresult = result;
78260   return jresult;
78261 }
78262
78263
78264 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
78265   unsigned int jresult ;
78266   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78267   unsigned int result;
78268
78269   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78270   {
78271     try {
78272       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
78273     } catch (std::out_of_range& e) {
78274       {
78275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78276       };
78277     } catch (std::exception& e) {
78278       {
78279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78280       };
78281     } catch (Dali::DaliException e) {
78282       {
78283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78284       };
78285     } catch (...) {
78286       {
78287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78288       };
78289     }
78290   }
78291
78292   jresult = result;
78293   return jresult;
78294 }
78295
78296
78297 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
78298   int jresult ;
78299   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78300   Dali::Toolkit::Ruler::RulerType result;
78301
78302   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78303   {
78304     try {
78305       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
78306     } catch (std::out_of_range& e) {
78307       {
78308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78309       };
78310     } catch (std::exception& e) {
78311       {
78312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78313       };
78314     } catch (Dali::DaliException e) {
78315       {
78316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78317       };
78318     } catch (...) {
78319       {
78320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78321       };
78322     }
78323   }
78324
78325   jresult = (int)result;
78326   return jresult;
78327 }
78328
78329
78330 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
78331   unsigned int jresult ;
78332   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78333   bool result;
78334
78335   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78336   {
78337     try {
78338       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
78339     } catch (std::out_of_range& e) {
78340       {
78341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78342       };
78343     } catch (std::exception& e) {
78344       {
78345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78346       };
78347     } catch (Dali::DaliException e) {
78348       {
78349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78350       };
78351     } catch (...) {
78352       {
78353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78354       };
78355     }
78356   }
78357
78358   jresult = result;
78359   return jresult;
78360 }
78361
78362
78363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
78364   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78365
78366   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78367   {
78368     try {
78369       (arg1)->Enable();
78370     } catch (std::out_of_range& e) {
78371       {
78372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78373       };
78374     } catch (std::exception& e) {
78375       {
78376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78377       };
78378     } catch (Dali::DaliException e) {
78379       {
78380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78381       };
78382     } catch (...) {
78383       {
78384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78385       };
78386     }
78387   }
78388
78389 }
78390
78391
78392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
78393   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78394
78395   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78396   {
78397     try {
78398       (arg1)->Disable();
78399     } catch (std::out_of_range& e) {
78400       {
78401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78402       };
78403     } catch (std::exception& e) {
78404       {
78405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78406       };
78407     } catch (Dali::DaliException e) {
78408       {
78409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78410       };
78411     } catch (...) {
78412       {
78413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78414       };
78415     }
78416   }
78417
78418 }
78419
78420
78421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
78422   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78423   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
78424   Dali::Toolkit::RulerDomain *argp2 ;
78425
78426   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78427   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
78428   if (!argp2) {
78429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
78430     return ;
78431   }
78432   arg2 = *argp2;
78433   {
78434     try {
78435       (arg1)->SetDomain(arg2);
78436     } catch (std::out_of_range& e) {
78437       {
78438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78439       };
78440     } catch (std::exception& e) {
78441       {
78442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78443       };
78444     } catch (Dali::DaliException e) {
78445       {
78446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78447       };
78448     } catch (...) {
78449       {
78450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78451       };
78452     }
78453   }
78454
78455 }
78456
78457
78458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
78459   void * jresult ;
78460   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78461   Dali::Toolkit::RulerDomain *result = 0 ;
78462
78463   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78464   {
78465     try {
78466       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
78467     } catch (std::out_of_range& e) {
78468       {
78469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78470       };
78471     } catch (std::exception& e) {
78472       {
78473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78474       };
78475     } catch (Dali::DaliException e) {
78476       {
78477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78478       };
78479     } catch (...) {
78480       {
78481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78482       };
78483     }
78484   }
78485
78486   jresult = (void *)result;
78487   return jresult;
78488 }
78489
78490
78491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
78492   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78493
78494   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78495   {
78496     try {
78497       (arg1)->DisableDomain();
78498     } catch (std::out_of_range& e) {
78499       {
78500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78501       };
78502     } catch (std::exception& e) {
78503       {
78504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78505       };
78506     } catch (Dali::DaliException e) {
78507       {
78508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78509       };
78510     } catch (...) {
78511       {
78512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78513       };
78514     }
78515   }
78516
78517 }
78518
78519
78520 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
78521   float jresult ;
78522   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78523   float arg2 ;
78524   float arg3 ;
78525   float arg4 ;
78526   float result;
78527
78528   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78529   arg2 = (float)jarg2;
78530   arg3 = (float)jarg3;
78531   arg4 = (float)jarg4;
78532   {
78533     try {
78534       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
78535     } catch (std::out_of_range& e) {
78536       {
78537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78538       };
78539     } catch (std::exception& e) {
78540       {
78541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78542       };
78543     } catch (Dali::DaliException e) {
78544       {
78545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78546       };
78547     } catch (...) {
78548       {
78549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78550       };
78551     }
78552   }
78553
78554   jresult = result;
78555   return jresult;
78556 }
78557
78558
78559 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
78560   float jresult ;
78561   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78562   float arg2 ;
78563   float arg3 ;
78564   float result;
78565
78566   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78567   arg2 = (float)jarg2;
78568   arg3 = (float)jarg3;
78569   {
78570     try {
78571       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
78572     } catch (std::out_of_range& e) {
78573       {
78574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78575       };
78576     } catch (std::exception& e) {
78577       {
78578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78579       };
78580     } catch (Dali::DaliException e) {
78581       {
78582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78583       };
78584     } catch (...) {
78585       {
78586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78587       };
78588     }
78589   }
78590
78591   jresult = result;
78592   return jresult;
78593 }
78594
78595
78596 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
78597   float jresult ;
78598   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78599   float arg2 ;
78600   float result;
78601
78602   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78603   arg2 = (float)jarg2;
78604   {
78605     try {
78606       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
78607     } catch (std::out_of_range& e) {
78608       {
78609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78610       };
78611     } catch (std::exception& e) {
78612       {
78613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78614       };
78615     } catch (Dali::DaliException e) {
78616       {
78617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78618       };
78619     } catch (...) {
78620       {
78621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78622       };
78623     }
78624   }
78625
78626   jresult = result;
78627   return jresult;
78628 }
78629
78630
78631 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
78632   float jresult ;
78633   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78634   float arg2 ;
78635   float arg3 ;
78636   float arg4 ;
78637   Dali::Toolkit::ClampState *arg5 = 0 ;
78638   float result;
78639
78640   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78641   arg2 = (float)jarg2;
78642   arg3 = (float)jarg3;
78643   arg4 = (float)jarg4;
78644   arg5 = (Dali::Toolkit::ClampState *)jarg5;
78645   if (!arg5) {
78646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78647     return 0;
78648   }
78649   {
78650     try {
78651       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
78652     } catch (std::out_of_range& e) {
78653       {
78654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78655       };
78656     } catch (std::exception& e) {
78657       {
78658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78659       };
78660     } catch (Dali::DaliException e) {
78661       {
78662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78663       };
78664     } catch (...) {
78665       {
78666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78667       };
78668     }
78669   }
78670
78671   jresult = result;
78672   return jresult;
78673 }
78674
78675
78676 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
78677   float jresult ;
78678   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78679   float arg2 ;
78680   float arg3 ;
78681   float arg4 ;
78682   float arg5 ;
78683   float result;
78684
78685   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78686   arg2 = (float)jarg2;
78687   arg3 = (float)jarg3;
78688   arg4 = (float)jarg4;
78689   arg5 = (float)jarg5;
78690   {
78691     try {
78692       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
78693     } catch (std::out_of_range& e) {
78694       {
78695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78696       };
78697     } catch (std::exception& e) {
78698       {
78699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78700       };
78701     } catch (Dali::DaliException e) {
78702       {
78703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78704       };
78705     } catch (...) {
78706       {
78707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78708       };
78709     }
78710   }
78711
78712   jresult = result;
78713   return jresult;
78714 }
78715
78716
78717 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
78718   float jresult ;
78719   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78720   float arg2 ;
78721   float arg3 ;
78722   float arg4 ;
78723   float result;
78724
78725   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78726   arg2 = (float)jarg2;
78727   arg3 = (float)jarg3;
78728   arg4 = (float)jarg4;
78729   {
78730     try {
78731       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
78732     } catch (std::out_of_range& e) {
78733       {
78734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78735       };
78736     } catch (std::exception& e) {
78737       {
78738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78739       };
78740     } catch (Dali::DaliException e) {
78741       {
78742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78743       };
78744     } catch (...) {
78745       {
78746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78747       };
78748     }
78749   }
78750
78751   jresult = result;
78752   return jresult;
78753 }
78754
78755
78756 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
78757   float jresult ;
78758   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78759   float arg2 ;
78760   float arg3 ;
78761   float result;
78762
78763   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78764   arg2 = (float)jarg2;
78765   arg3 = (float)jarg3;
78766   {
78767     try {
78768       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
78769     } catch (std::out_of_range& e) {
78770       {
78771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78772       };
78773     } catch (std::exception& e) {
78774       {
78775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78776       };
78777     } catch (Dali::DaliException e) {
78778       {
78779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78780       };
78781     } catch (...) {
78782       {
78783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78784       };
78785     }
78786   }
78787
78788   jresult = result;
78789   return jresult;
78790 }
78791
78792
78793 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
78794   float jresult ;
78795   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78796   float arg2 ;
78797   float result;
78798
78799   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78800   arg2 = (float)jarg2;
78801   {
78802     try {
78803       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
78804     } catch (std::out_of_range& e) {
78805       {
78806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78807       };
78808     } catch (std::exception& e) {
78809       {
78810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78811       };
78812     } catch (Dali::DaliException e) {
78813       {
78814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78815       };
78816     } catch (...) {
78817       {
78818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78819       };
78820     }
78821   }
78822
78823   jresult = result;
78824   return jresult;
78825 }
78826
78827
78828 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
78829   float jresult ;
78830   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78831   float arg2 ;
78832   float arg3 ;
78833   float arg4 ;
78834   float arg5 ;
78835   Dali::Toolkit::ClampState *arg6 = 0 ;
78836   float result;
78837
78838   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78839   arg2 = (float)jarg2;
78840   arg3 = (float)jarg3;
78841   arg4 = (float)jarg4;
78842   arg5 = (float)jarg5;
78843   arg6 = (Dali::Toolkit::ClampState *)jarg6;
78844   if (!arg6) {
78845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78846     return 0;
78847   }
78848   {
78849     try {
78850       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
78851     } catch (std::out_of_range& e) {
78852       {
78853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78854       };
78855     } catch (std::exception& e) {
78856       {
78857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78858       };
78859     } catch (Dali::DaliException e) {
78860       {
78861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78862       };
78863     } catch (...) {
78864       {
78865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78866       };
78867     }
78868   }
78869
78870   jresult = result;
78871   return jresult;
78872 }
78873
78874
78875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
78876   void * jresult ;
78877   Dali::Toolkit::DefaultRuler *result = 0 ;
78878
78879   {
78880     try {
78881       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
78882     } catch (std::out_of_range& e) {
78883       {
78884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78885       };
78886     } catch (std::exception& e) {
78887       {
78888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78889       };
78890     } catch (Dali::DaliException e) {
78891       {
78892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78893       };
78894     } catch (...) {
78895       {
78896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78897       };
78898     }
78899   }
78900
78901   jresult = (void *)result;
78902   return jresult;
78903 }
78904
78905
78906 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
78907   float jresult ;
78908   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78909   float arg2 ;
78910   float arg3 ;
78911   float result;
78912
78913   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78914   arg2 = (float)jarg2;
78915   arg3 = (float)jarg3;
78916   {
78917     try {
78918       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
78919     } catch (std::out_of_range& e) {
78920       {
78921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78922       };
78923     } catch (std::exception& e) {
78924       {
78925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78926       };
78927     } catch (Dali::DaliException e) {
78928       {
78929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78930       };
78931     } catch (...) {
78932       {
78933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78934       };
78935     }
78936   }
78937
78938   jresult = result;
78939   return jresult;
78940 }
78941
78942
78943 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78944   float jresult ;
78945   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78946   unsigned int arg2 ;
78947   unsigned int *arg3 = 0 ;
78948   bool arg4 ;
78949   float result;
78950
78951   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78952   arg2 = (unsigned int)jarg2;
78953   arg3 = (unsigned int *)jarg3;
78954   arg4 = jarg4 ? true : false;
78955   {
78956     try {
78957       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78958     } catch (std::out_of_range& e) {
78959       {
78960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78961       };
78962     } catch (std::exception& e) {
78963       {
78964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78965       };
78966     } catch (Dali::DaliException e) {
78967       {
78968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78969       };
78970     } catch (...) {
78971       {
78972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78973       };
78974     }
78975   }
78976
78977   jresult = result;
78978   return jresult;
78979 }
78980
78981
78982 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78983   unsigned int jresult ;
78984   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78985   float arg2 ;
78986   bool arg3 ;
78987   unsigned int result;
78988
78989   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78990   arg2 = (float)jarg2;
78991   arg3 = jarg3 ? true : false;
78992   {
78993     try {
78994       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
78995     } catch (std::out_of_range& e) {
78996       {
78997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78998       };
78999     } catch (std::exception& e) {
79000       {
79001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79002       };
79003     } catch (Dali::DaliException e) {
79004       {
79005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79006       };
79007     } catch (...) {
79008       {
79009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79010       };
79011     }
79012   }
79013
79014   jresult = result;
79015   return jresult;
79016 }
79017
79018
79019 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
79020   unsigned int jresult ;
79021   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79022   unsigned int result;
79023
79024   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79025   {
79026     try {
79027       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
79028     } catch (std::out_of_range& e) {
79029       {
79030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79031       };
79032     } catch (std::exception& e) {
79033       {
79034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79035       };
79036     } catch (Dali::DaliException e) {
79037       {
79038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79039       };
79040     } catch (...) {
79041       {
79042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79043       };
79044     }
79045   }
79046
79047   jresult = result;
79048   return jresult;
79049 }
79050
79051
79052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
79053   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79054
79055   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79056   {
79057     try {
79058       delete arg1;
79059     } catch (std::out_of_range& e) {
79060       {
79061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79062       };
79063     } catch (std::exception& e) {
79064       {
79065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79066       };
79067     } catch (Dali::DaliException e) {
79068       {
79069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79070       };
79071     } catch (...) {
79072       {
79073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79074       };
79075     }
79076   }
79077
79078 }
79079
79080
79081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
79082   void * jresult ;
79083   float arg1 ;
79084   Dali::Toolkit::FixedRuler *result = 0 ;
79085
79086   arg1 = (float)jarg1;
79087   {
79088     try {
79089       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
79090     } catch (std::out_of_range& e) {
79091       {
79092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79093       };
79094     } catch (std::exception& e) {
79095       {
79096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79097       };
79098     } catch (Dali::DaliException e) {
79099       {
79100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79101       };
79102     } catch (...) {
79103       {
79104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79105       };
79106     }
79107   }
79108
79109   jresult = (void *)result;
79110   return jresult;
79111 }
79112
79113
79114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
79115   void * jresult ;
79116   Dali::Toolkit::FixedRuler *result = 0 ;
79117
79118   {
79119     try {
79120       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
79121     } catch (std::out_of_range& e) {
79122       {
79123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79124       };
79125     } catch (std::exception& e) {
79126       {
79127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79128       };
79129     } catch (Dali::DaliException e) {
79130       {
79131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79132       };
79133     } catch (...) {
79134       {
79135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79136       };
79137     }
79138   }
79139
79140   jresult = (void *)result;
79141   return jresult;
79142 }
79143
79144
79145 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
79146   float jresult ;
79147   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79148   float arg2 ;
79149   float arg3 ;
79150   float result;
79151
79152   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79153   arg2 = (float)jarg2;
79154   arg3 = (float)jarg3;
79155   {
79156     try {
79157       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
79158     } catch (std::out_of_range& e) {
79159       {
79160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79161       };
79162     } catch (std::exception& e) {
79163       {
79164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79165       };
79166     } catch (Dali::DaliException e) {
79167       {
79168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79169       };
79170     } catch (...) {
79171       {
79172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79173       };
79174     }
79175   }
79176
79177   jresult = result;
79178   return jresult;
79179 }
79180
79181
79182 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
79183   float jresult ;
79184   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79185   unsigned int arg2 ;
79186   unsigned int *arg3 = 0 ;
79187   bool arg4 ;
79188   float result;
79189
79190   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79191   arg2 = (unsigned int)jarg2;
79192   arg3 = (unsigned int *)jarg3;
79193   arg4 = jarg4 ? true : false;
79194   {
79195     try {
79196       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
79197     } catch (std::out_of_range& e) {
79198       {
79199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79200       };
79201     } catch (std::exception& e) {
79202       {
79203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79204       };
79205     } catch (Dali::DaliException e) {
79206       {
79207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79208       };
79209     } catch (...) {
79210       {
79211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79212       };
79213     }
79214   }
79215
79216   jresult = result;
79217   return jresult;
79218 }
79219
79220
79221 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
79222   unsigned int jresult ;
79223   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79224   float arg2 ;
79225   bool arg3 ;
79226   unsigned int result;
79227
79228   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79229   arg2 = (float)jarg2;
79230   arg3 = jarg3 ? true : false;
79231   {
79232     try {
79233       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
79234     } catch (std::out_of_range& e) {
79235       {
79236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79237       };
79238     } catch (std::exception& e) {
79239       {
79240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79241       };
79242     } catch (Dali::DaliException e) {
79243       {
79244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79245       };
79246     } catch (...) {
79247       {
79248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79249       };
79250     }
79251   }
79252
79253   jresult = result;
79254   return jresult;
79255 }
79256
79257
79258 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
79259   unsigned int jresult ;
79260   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79261   unsigned int result;
79262
79263   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79264   {
79265     try {
79266       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
79267     } catch (std::out_of_range& e) {
79268       {
79269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79270       };
79271     } catch (std::exception& e) {
79272       {
79273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79274       };
79275     } catch (Dali::DaliException e) {
79276       {
79277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79278       };
79279     } catch (...) {
79280       {
79281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79282       };
79283     }
79284   }
79285
79286   jresult = result;
79287   return jresult;
79288 }
79289
79290
79291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
79292   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79293
79294   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79295   {
79296     try {
79297       delete arg1;
79298     } catch (std::out_of_range& e) {
79299       {
79300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79301       };
79302     } catch (std::exception& e) {
79303       {
79304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79305       };
79306     } catch (Dali::DaliException e) {
79307       {
79308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79309       };
79310     } catch (...) {
79311       {
79312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79313       };
79314     }
79315   }
79316
79317 }
79318
79319
79320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
79321   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79322   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79323
79324   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79325   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79326   if (arg1) (arg1)->scale = *arg2;
79327 }
79328
79329
79330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
79331   void * jresult ;
79332   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79333   Dali::Toolkit::ClampState2D *result = 0 ;
79334
79335   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79336   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
79337   jresult = (void *)result;
79338   return jresult;
79339 }
79340
79341
79342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
79343   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79344   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79345
79346   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79347   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79348   if (arg1) (arg1)->position = *arg2;
79349 }
79350
79351
79352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
79353   void * jresult ;
79354   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79355   Dali::Toolkit::ClampState2D *result = 0 ;
79356
79357   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79358   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
79359   jresult = (void *)result;
79360   return jresult;
79361 }
79362
79363
79364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
79365   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79366   Dali::Toolkit::ClampState arg2 ;
79367
79368   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79369   arg2 = (Dali::Toolkit::ClampState)jarg2;
79370   if (arg1) (arg1)->rotation = arg2;
79371 }
79372
79373
79374 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
79375   int jresult ;
79376   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79377   Dali::Toolkit::ClampState result;
79378
79379   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79380   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
79381   jresult = (int)result;
79382   return jresult;
79383 }
79384
79385
79386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
79387   void * jresult ;
79388   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
79389
79390   {
79391     try {
79392       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
79393     } catch (std::out_of_range& e) {
79394       {
79395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79396       };
79397     } catch (std::exception& e) {
79398       {
79399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79400       };
79401     } catch (Dali::DaliException e) {
79402       {
79403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79404       };
79405     } catch (...) {
79406       {
79407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79408       };
79409     }
79410   }
79411
79412   jresult = (void *)result;
79413   return jresult;
79414 }
79415
79416
79417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
79418   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79419
79420   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79421   {
79422     try {
79423       delete arg1;
79424     } catch (std::out_of_range& e) {
79425       {
79426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79427       };
79428     } catch (std::exception& e) {
79429       {
79430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79431       };
79432     } catch (Dali::DaliException e) {
79433       {
79434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79435       };
79436     } catch (...) {
79437       {
79438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79439       };
79440     }
79441   }
79442
79443 }
79444
79445
79446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
79447   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79448   Dali::Toolkit::SnapType arg2 ;
79449
79450   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79451   arg2 = (Dali::Toolkit::SnapType)jarg2;
79452   if (arg1) (arg1)->type = arg2;
79453 }
79454
79455
79456 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
79457   int jresult ;
79458   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79459   Dali::Toolkit::SnapType result;
79460
79461   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79462   result = (Dali::Toolkit::SnapType) ((arg1)->type);
79463   jresult = (int)result;
79464   return jresult;
79465 }
79466
79467
79468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
79469   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79470   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
79471
79472   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79473   arg2 = (Dali::Vector2 *)jarg2;
79474   if (arg1) (arg1)->position = *arg2;
79475 }
79476
79477
79478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
79479   void * jresult ;
79480   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79481   Dali::Vector2 *result = 0 ;
79482
79483   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79484   result = (Dali::Vector2 *)& ((arg1)->position);
79485   jresult = (void *)result;
79486   return jresult;
79487 }
79488
79489
79490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
79491   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79492   float arg2 ;
79493
79494   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79495   arg2 = (float)jarg2;
79496   if (arg1) (arg1)->duration = arg2;
79497 }
79498
79499
79500 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
79501   float jresult ;
79502   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79503   float result;
79504
79505   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79506   result = (float) ((arg1)->duration);
79507   jresult = result;
79508   return jresult;
79509 }
79510
79511
79512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
79513   void * jresult ;
79514   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
79515
79516   {
79517     try {
79518       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
79519     } catch (std::out_of_range& e) {
79520       {
79521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79522       };
79523     } catch (std::exception& e) {
79524       {
79525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79526       };
79527     } catch (Dali::DaliException e) {
79528       {
79529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79530       };
79531     } catch (...) {
79532       {
79533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79534       };
79535     }
79536   }
79537
79538   jresult = (void *)result;
79539   return jresult;
79540 }
79541
79542
79543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
79544   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79545
79546   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79547   {
79548     try {
79549       delete arg1;
79550     } catch (std::out_of_range& e) {
79551       {
79552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79553       };
79554     } catch (std::exception& e) {
79555       {
79556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79557       };
79558     } catch (Dali::DaliException e) {
79559       {
79560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79561       };
79562     } catch (...) {
79563       {
79564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79565       };
79566     }
79567   }
79568
79569 }
79570
79571
79572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
79573   int jresult ;
79574   int result;
79575
79576   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
79577   jresult = (int)result;
79578   return jresult;
79579 }
79580
79581
79582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
79583   int jresult ;
79584   int result;
79585
79586   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
79587   jresult = (int)result;
79588   return jresult;
79589 }
79590
79591
79592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
79593   int jresult ;
79594   int result;
79595
79596   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
79597   jresult = (int)result;
79598   return jresult;
79599 }
79600
79601
79602 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
79603   int jresult ;
79604   int result;
79605
79606   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
79607   jresult = (int)result;
79608   return jresult;
79609 }
79610
79611
79612 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
79613   int jresult ;
79614   int result;
79615
79616   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
79617   jresult = (int)result;
79618   return jresult;
79619 }
79620
79621 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
79622   int jresult ;
79623   int result;
79624
79625   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
79626   jresult = (int)result;
79627   return jresult;
79628 }
79629
79630
79631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
79632   int jresult ;
79633   int result;
79634
79635   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
79636   jresult = (int)result;
79637   return jresult;
79638 }
79639
79640
79641 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
79642   int jresult ;
79643   int result;
79644
79645   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
79646   jresult = (int)result;
79647   return jresult;
79648 }
79649
79650
79651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
79652   int jresult ;
79653   int result;
79654
79655   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
79656   jresult = (int)result;
79657   return jresult;
79658 }
79659
79660
79661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
79662   int jresult ;
79663   int result;
79664
79665   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
79666   jresult = (int)result;
79667   return jresult;
79668 }
79669
79670
79671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
79672   int jresult ;
79673   int result;
79674
79675   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
79676   jresult = (int)result;
79677   return jresult;
79678 }
79679
79680
79681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
79682   int jresult ;
79683   int result;
79684
79685   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
79686   jresult = (int)result;
79687   return jresult;
79688 }
79689
79690
79691 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
79692   int jresult ;
79693   int result;
79694
79695   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
79696   jresult = (int)result;
79697   return jresult;
79698 }
79699
79700
79701 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
79702   int jresult ;
79703   int result;
79704
79705   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
79706   jresult = (int)result;
79707   return jresult;
79708 }
79709
79710
79711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
79712   int jresult ;
79713   int result;
79714
79715   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
79716   jresult = (int)result;
79717   return jresult;
79718 }
79719
79720
79721 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
79722   int jresult ;
79723   int result;
79724
79725   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
79726   jresult = (int)result;
79727   return jresult;
79728 }
79729
79730
79731 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
79732   int jresult ;
79733   int result;
79734
79735   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
79736   jresult = (int)result;
79737   return jresult;
79738 }
79739
79740
79741 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
79742   int jresult ;
79743   int result;
79744
79745   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
79746   jresult = (int)result;
79747   return jresult;
79748 }
79749
79750
79751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
79752   int jresult ;
79753   int result;
79754
79755   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
79756   jresult = (int)result;
79757   return jresult;
79758 }
79759
79760
79761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
79762   int jresult ;
79763   int result;
79764
79765   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
79766   jresult = (int)result;
79767   return jresult;
79768 }
79769
79770
79771 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
79772   int jresult ;
79773   int result;
79774
79775   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
79776   jresult = (int)result;
79777   return jresult;
79778 }
79779
79780
79781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
79782   int jresult ;
79783   int result;
79784
79785   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
79786   jresult = (int)result;
79787   return jresult;
79788 }
79789
79790
79791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
79792   int jresult ;
79793   int result;
79794
79795   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
79796   jresult = (int)result;
79797   return jresult;
79798 }
79799
79800
79801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
79802   int jresult ;
79803   int result;
79804
79805   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
79806   jresult = (int)result;
79807   return jresult;
79808 }
79809
79810
79811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
79812   int jresult ;
79813   int result;
79814
79815   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
79816   jresult = (int)result;
79817   return jresult;
79818 }
79819
79820
79821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
79822   int jresult ;
79823   int result;
79824
79825   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
79826   jresult = (int)result;
79827   return jresult;
79828 }
79829
79830
79831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
79832   void * jresult ;
79833   Dali::Toolkit::ScrollView::Property *result = 0 ;
79834
79835   {
79836     try {
79837       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
79838     } catch (std::out_of_range& e) {
79839       {
79840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79841       };
79842     } catch (std::exception& e) {
79843       {
79844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79845       };
79846     } catch (Dali::DaliException e) {
79847       {
79848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79849       };
79850     } catch (...) {
79851       {
79852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79853       };
79854     }
79855   }
79856
79857   jresult = (void *)result;
79858   return jresult;
79859 }
79860
79861
79862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
79863   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
79864
79865   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
79866   {
79867     try {
79868       delete arg1;
79869     } catch (std::out_of_range& e) {
79870       {
79871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79872       };
79873     } catch (std::exception& e) {
79874       {
79875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79876       };
79877     } catch (Dali::DaliException e) {
79878       {
79879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79880       };
79881     } catch (...) {
79882       {
79883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79884       };
79885     }
79886   }
79887
79888 }
79889
79890
79891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
79892   void * jresult ;
79893   Dali::Toolkit::ScrollView *result = 0 ;
79894
79895   {
79896     try {
79897       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
79898     } catch (std::out_of_range& e) {
79899       {
79900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79901       };
79902     } catch (std::exception& e) {
79903       {
79904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79905       };
79906     } catch (Dali::DaliException e) {
79907       {
79908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79909       };
79910     } catch (...) {
79911       {
79912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79913       };
79914     }
79915   }
79916
79917   jresult = (void *)result;
79918   return jresult;
79919 }
79920
79921
79922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
79923   void * jresult ;
79924   Dali::Toolkit::ScrollView *arg1 = 0 ;
79925   Dali::Toolkit::ScrollView *result = 0 ;
79926
79927   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79928   if (!arg1) {
79929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
79930     return 0;
79931   }
79932   {
79933     try {
79934       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
79935     } catch (std::out_of_range& e) {
79936       {
79937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79938       };
79939     } catch (std::exception& e) {
79940       {
79941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79942       };
79943     } catch (Dali::DaliException e) {
79944       {
79945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79946       };
79947     } catch (...) {
79948       {
79949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79950       };
79951     }
79952   }
79953
79954   jresult = (void *)result;
79955   return jresult;
79956 }
79957
79958
79959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
79960   void * jresult ;
79961   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79962   Dali::Toolkit::ScrollView *arg2 = 0 ;
79963   Dali::Toolkit::ScrollView *result = 0 ;
79964
79965   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79966   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
79967   if (!arg2) {
79968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
79969     return 0;
79970   }
79971   {
79972     try {
79973       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
79974     } catch (std::out_of_range& e) {
79975       {
79976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79977       };
79978     } catch (std::exception& e) {
79979       {
79980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79981       };
79982     } catch (Dali::DaliException e) {
79983       {
79984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79985       };
79986     } catch (...) {
79987       {
79988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79989       };
79990     }
79991   }
79992
79993   jresult = (void *)result;
79994   return jresult;
79995 }
79996
79997
79998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
79999   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80000
80001   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80002   {
80003     try {
80004       delete arg1;
80005     } catch (std::out_of_range& e) {
80006       {
80007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80008       };
80009     } catch (std::exception& e) {
80010       {
80011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80012       };
80013     } catch (Dali::DaliException e) {
80014       {
80015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80016       };
80017     } catch (...) {
80018       {
80019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80020       };
80021     }
80022   }
80023
80024 }
80025
80026
80027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
80028   void * jresult ;
80029   Dali::Toolkit::ScrollView result;
80030
80031   {
80032     try {
80033       result = Dali::Toolkit::ScrollView::New();
80034     } catch (std::out_of_range& e) {
80035       {
80036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80037       };
80038     } catch (std::exception& e) {
80039       {
80040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80041       };
80042     } catch (Dali::DaliException e) {
80043       {
80044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80045       };
80046     } catch (...) {
80047       {
80048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80049       };
80050     }
80051   }
80052
80053   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
80054   return jresult;
80055 }
80056
80057
80058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
80059   void * jresult ;
80060   Dali::BaseHandle arg1 ;
80061   Dali::BaseHandle *argp1 ;
80062   Dali::Toolkit::ScrollView result;
80063
80064   argp1 = (Dali::BaseHandle *)jarg1;
80065   if (!argp1) {
80066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
80067     return 0;
80068   }
80069   arg1 = *argp1;
80070   {
80071     try {
80072       result = Dali::Toolkit::ScrollView::DownCast(arg1);
80073     } catch (std::out_of_range& e) {
80074       {
80075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80076       };
80077     } catch (std::exception& e) {
80078       {
80079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80080       };
80081     } catch (Dali::DaliException e) {
80082       {
80083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80084       };
80085     } catch (...) {
80086       {
80087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80088       };
80089     }
80090   }
80091
80092   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
80093   return jresult;
80094 }
80095
80096
80097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
80098   void * jresult ;
80099   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80100   Dali::AlphaFunction result;
80101
80102   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80103   {
80104     try {
80105       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
80106     } catch (std::out_of_range& e) {
80107       {
80108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80109       };
80110     } catch (std::exception& e) {
80111       {
80112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80113       };
80114     } catch (Dali::DaliException e) {
80115       {
80116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80117       };
80118     } catch (...) {
80119       {
80120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80121       };
80122     }
80123   }
80124
80125   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80126   return jresult;
80127 }
80128
80129
80130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
80131   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80132   Dali::AlphaFunction arg2 ;
80133   Dali::AlphaFunction *argp2 ;
80134
80135   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80136   argp2 = (Dali::AlphaFunction *)jarg2;
80137   if (!argp2) {
80138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80139     return ;
80140   }
80141   arg2 = *argp2;
80142   {
80143     try {
80144       (arg1)->SetScrollSnapAlphaFunction(arg2);
80145     } catch (std::out_of_range& e) {
80146       {
80147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80148       };
80149     } catch (std::exception& e) {
80150       {
80151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80152       };
80153     } catch (Dali::DaliException e) {
80154       {
80155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80156       };
80157     } catch (...) {
80158       {
80159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80160       };
80161     }
80162   }
80163
80164 }
80165
80166
80167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
80168   void * jresult ;
80169   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80170   Dali::AlphaFunction result;
80171
80172   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80173   {
80174     try {
80175       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
80176     } catch (std::out_of_range& e) {
80177       {
80178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80179       };
80180     } catch (std::exception& e) {
80181       {
80182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80183       };
80184     } catch (Dali::DaliException e) {
80185       {
80186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80187       };
80188     } catch (...) {
80189       {
80190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80191       };
80192     }
80193   }
80194
80195   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80196   return jresult;
80197 }
80198
80199
80200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
80201   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80202   Dali::AlphaFunction arg2 ;
80203   Dali::AlphaFunction *argp2 ;
80204
80205   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80206   argp2 = (Dali::AlphaFunction *)jarg2;
80207   if (!argp2) {
80208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80209     return ;
80210   }
80211   arg2 = *argp2;
80212   {
80213     try {
80214       (arg1)->SetScrollFlickAlphaFunction(arg2);
80215     } catch (std::out_of_range& e) {
80216       {
80217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80218       };
80219     } catch (std::exception& e) {
80220       {
80221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80222       };
80223     } catch (Dali::DaliException e) {
80224       {
80225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80226       };
80227     } catch (...) {
80228       {
80229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80230       };
80231     }
80232   }
80233
80234 }
80235
80236
80237 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
80238   float jresult ;
80239   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80240   float result;
80241
80242   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80243   {
80244     try {
80245       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
80246     } catch (std::out_of_range& e) {
80247       {
80248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80249       };
80250     } catch (std::exception& e) {
80251       {
80252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80253       };
80254     } catch (Dali::DaliException e) {
80255       {
80256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80257       };
80258     } catch (...) {
80259       {
80260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80261       };
80262     }
80263   }
80264
80265   jresult = result;
80266   return jresult;
80267 }
80268
80269
80270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
80271   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80272   float arg2 ;
80273
80274   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80275   arg2 = (float)jarg2;
80276   {
80277     try {
80278       (arg1)->SetScrollSnapDuration(arg2);
80279     } catch (std::out_of_range& e) {
80280       {
80281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80282       };
80283     } catch (std::exception& e) {
80284       {
80285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80286       };
80287     } catch (Dali::DaliException e) {
80288       {
80289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80290       };
80291     } catch (...) {
80292       {
80293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80294       };
80295     }
80296   }
80297
80298 }
80299
80300
80301 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
80302   float jresult ;
80303   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80304   float result;
80305
80306   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80307   {
80308     try {
80309       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
80310     } catch (std::out_of_range& e) {
80311       {
80312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80313       };
80314     } catch (std::exception& e) {
80315       {
80316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80317       };
80318     } catch (Dali::DaliException e) {
80319       {
80320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80321       };
80322     } catch (...) {
80323       {
80324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80325       };
80326     }
80327   }
80328
80329   jresult = result;
80330   return jresult;
80331 }
80332
80333
80334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
80335   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80336   float arg2 ;
80337
80338   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80339   arg2 = (float)jarg2;
80340   {
80341     try {
80342       (arg1)->SetScrollFlickDuration(arg2);
80343     } catch (std::out_of_range& e) {
80344       {
80345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80346       };
80347     } catch (std::exception& e) {
80348       {
80349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80350       };
80351     } catch (Dali::DaliException e) {
80352       {
80353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80354       };
80355     } catch (...) {
80356       {
80357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80358       };
80359     }
80360   }
80361
80362 }
80363
80364
80365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
80366   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80367   Dali::Toolkit::RulerPtr arg2 ;
80368   Dali::Toolkit::RulerPtr *argp2 ;
80369
80370   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80371   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80372   if (!argp2) {
80373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80374     return ;
80375   }
80376   arg2 = *argp2;
80377   {
80378     try {
80379       (arg1)->SetRulerX(arg2);
80380     } catch (std::out_of_range& e) {
80381       {
80382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80383       };
80384     } catch (std::exception& e) {
80385       {
80386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80387       };
80388     } catch (Dali::DaliException e) {
80389       {
80390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80391       };
80392     } catch (...) {
80393       {
80394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80395       };
80396     }
80397   }
80398
80399 }
80400
80401
80402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
80403   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80404   Dali::Toolkit::RulerPtr arg2 ;
80405   Dali::Toolkit::RulerPtr *argp2 ;
80406
80407   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80408   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80409   if (!argp2) {
80410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80411     return ;
80412   }
80413   arg2 = *argp2;
80414   {
80415     try {
80416       (arg1)->SetRulerY(arg2);
80417     } catch (std::out_of_range& e) {
80418       {
80419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80420       };
80421     } catch (std::exception& e) {
80422       {
80423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80424       };
80425     } catch (Dali::DaliException e) {
80426       {
80427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80428       };
80429     } catch (...) {
80430       {
80431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80432       };
80433     }
80434   }
80435
80436 }
80437
80438
80439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
80440   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80441   bool arg2 ;
80442
80443   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80444   arg2 = jarg2 ? true : false;
80445   {
80446     try {
80447       (arg1)->SetScrollSensitive(arg2);
80448     } catch (std::out_of_range& e) {
80449       {
80450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80451       };
80452     } catch (std::exception& e) {
80453       {
80454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80455       };
80456     } catch (Dali::DaliException e) {
80457       {
80458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80459       };
80460     } catch (...) {
80461       {
80462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80463       };
80464     }
80465   }
80466
80467 }
80468
80469
80470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
80471   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80472   float arg2 ;
80473   float arg3 ;
80474
80475   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80476   arg2 = (float)jarg2;
80477   arg3 = (float)jarg3;
80478   {
80479     try {
80480       (arg1)->SetMaxOvershoot(arg2,arg3);
80481     } catch (std::out_of_range& e) {
80482       {
80483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80484       };
80485     } catch (std::exception& e) {
80486       {
80487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80488       };
80489     } catch (Dali::DaliException e) {
80490       {
80491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80492       };
80493     } catch (...) {
80494       {
80495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80496       };
80497     }
80498   }
80499
80500 }
80501
80502
80503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
80504   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80505   Dali::AlphaFunction arg2 ;
80506   Dali::AlphaFunction *argp2 ;
80507
80508   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80509   argp2 = (Dali::AlphaFunction *)jarg2;
80510   if (!argp2) {
80511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80512     return ;
80513   }
80514   arg2 = *argp2;
80515   {
80516     try {
80517       (arg1)->SetSnapOvershootAlphaFunction(arg2);
80518     } catch (std::out_of_range& e) {
80519       {
80520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80521       };
80522     } catch (std::exception& e) {
80523       {
80524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80525       };
80526     } catch (Dali::DaliException e) {
80527       {
80528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80529       };
80530     } catch (...) {
80531       {
80532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80533       };
80534     }
80535   }
80536
80537 }
80538
80539
80540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
80541   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80542   float arg2 ;
80543
80544   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80545   arg2 = (float)jarg2;
80546   {
80547     try {
80548       (arg1)->SetSnapOvershootDuration(arg2);
80549     } catch (std::out_of_range& e) {
80550       {
80551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80552       };
80553     } catch (std::exception& e) {
80554       {
80555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80556       };
80557     } catch (Dali::DaliException e) {
80558       {
80559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80560       };
80561     } catch (...) {
80562       {
80563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80564       };
80565     }
80566   }
80567
80568 }
80569
80570
80571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
80572   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80573   bool arg2 ;
80574
80575   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80576   arg2 = jarg2 ? true : false;
80577   {
80578     try {
80579       (arg1)->SetActorAutoSnap(arg2);
80580     } catch (std::out_of_range& e) {
80581       {
80582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80583       };
80584     } catch (std::exception& e) {
80585       {
80586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80587       };
80588     } catch (Dali::DaliException e) {
80589       {
80590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80591       };
80592     } catch (...) {
80593       {
80594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80595       };
80596     }
80597   }
80598
80599 }
80600
80601
80602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
80603   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80604   bool arg2 ;
80605
80606   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80607   arg2 = jarg2 ? true : false;
80608   {
80609     try {
80610       (arg1)->SetWrapMode(arg2);
80611     } catch (std::out_of_range& e) {
80612       {
80613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80614       };
80615     } catch (std::exception& e) {
80616       {
80617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80618       };
80619     } catch (Dali::DaliException e) {
80620       {
80621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80622       };
80623     } catch (...) {
80624       {
80625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80626       };
80627     }
80628   }
80629
80630 }
80631
80632
80633 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
80634   int jresult ;
80635   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80636   int result;
80637
80638   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80639   {
80640     try {
80641       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
80642     } catch (std::out_of_range& e) {
80643       {
80644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80645       };
80646     } catch (std::exception& e) {
80647       {
80648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80649       };
80650     } catch (Dali::DaliException e) {
80651       {
80652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80653       };
80654     } catch (...) {
80655       {
80656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80657       };
80658     }
80659   }
80660
80661   jresult = result;
80662   return jresult;
80663 }
80664
80665
80666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
80667   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80668   int arg2 ;
80669
80670   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80671   arg2 = (int)jarg2;
80672   {
80673     try {
80674       (arg1)->SetScrollUpdateDistance(arg2);
80675     } catch (std::out_of_range& e) {
80676       {
80677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80678       };
80679     } catch (std::exception& e) {
80680       {
80681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80682       };
80683     } catch (Dali::DaliException e) {
80684       {
80685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80686       };
80687     } catch (...) {
80688       {
80689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80690       };
80691     }
80692   }
80693
80694 }
80695
80696
80697 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
80698   unsigned int jresult ;
80699   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80700   bool result;
80701
80702   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80703   {
80704     try {
80705       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
80706     } catch (std::out_of_range& e) {
80707       {
80708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80709       };
80710     } catch (std::exception& e) {
80711       {
80712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80713       };
80714     } catch (Dali::DaliException e) {
80715       {
80716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80717       };
80718     } catch (...) {
80719       {
80720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80721       };
80722     }
80723   }
80724
80725   jresult = result;
80726   return jresult;
80727 }
80728
80729
80730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
80731   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80732   bool arg2 ;
80733
80734   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80735   arg2 = jarg2 ? true : false;
80736   {
80737     try {
80738       (arg1)->SetAxisAutoLock(arg2);
80739     } catch (std::out_of_range& e) {
80740       {
80741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80742       };
80743     } catch (std::exception& e) {
80744       {
80745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80746       };
80747     } catch (Dali::DaliException e) {
80748       {
80749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80750       };
80751     } catch (...) {
80752       {
80753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80754       };
80755     }
80756   }
80757
80758 }
80759
80760
80761 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
80762   float jresult ;
80763   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80764   float result;
80765
80766   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80767   {
80768     try {
80769       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
80770     } catch (std::out_of_range& e) {
80771       {
80772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80773       };
80774     } catch (std::exception& e) {
80775       {
80776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80777       };
80778     } catch (Dali::DaliException e) {
80779       {
80780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80781       };
80782     } catch (...) {
80783       {
80784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80785       };
80786     }
80787   }
80788
80789   jresult = result;
80790   return jresult;
80791 }
80792
80793
80794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
80795   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80796   float arg2 ;
80797
80798   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80799   arg2 = (float)jarg2;
80800   {
80801     try {
80802       (arg1)->SetAxisAutoLockGradient(arg2);
80803     } catch (std::out_of_range& e) {
80804       {
80805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80806       };
80807     } catch (std::exception& e) {
80808       {
80809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80810       };
80811     } catch (Dali::DaliException e) {
80812       {
80813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80814       };
80815     } catch (...) {
80816       {
80817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80818       };
80819     }
80820   }
80821
80822 }
80823
80824
80825 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
80826   float jresult ;
80827   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80828   float result;
80829
80830   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80831   {
80832     try {
80833       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
80834     } catch (std::out_of_range& e) {
80835       {
80836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80837       };
80838     } catch (std::exception& e) {
80839       {
80840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80841       };
80842     } catch (Dali::DaliException e) {
80843       {
80844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80845       };
80846     } catch (...) {
80847       {
80848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80849       };
80850     }
80851   }
80852
80853   jresult = result;
80854   return jresult;
80855 }
80856
80857
80858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
80859   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80860   float arg2 ;
80861
80862   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80863   arg2 = (float)jarg2;
80864   {
80865     try {
80866       (arg1)->SetFrictionCoefficient(arg2);
80867     } catch (std::out_of_range& e) {
80868       {
80869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80870       };
80871     } catch (std::exception& e) {
80872       {
80873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80874       };
80875     } catch (Dali::DaliException e) {
80876       {
80877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80878       };
80879     } catch (...) {
80880       {
80881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80882       };
80883     }
80884   }
80885
80886 }
80887
80888
80889 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
80890   float jresult ;
80891   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80892   float result;
80893
80894   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80895   {
80896     try {
80897       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
80898     } catch (std::out_of_range& e) {
80899       {
80900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80901       };
80902     } catch (std::exception& e) {
80903       {
80904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80905       };
80906     } catch (Dali::DaliException e) {
80907       {
80908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80909       };
80910     } catch (...) {
80911       {
80912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80913       };
80914     }
80915   }
80916
80917   jresult = result;
80918   return jresult;
80919 }
80920
80921
80922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
80923   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80924   float arg2 ;
80925
80926   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80927   arg2 = (float)jarg2;
80928   {
80929     try {
80930       (arg1)->SetFlickSpeedCoefficient(arg2);
80931     } catch (std::out_of_range& e) {
80932       {
80933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80934       };
80935     } catch (std::exception& e) {
80936       {
80937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80938       };
80939     } catch (Dali::DaliException e) {
80940       {
80941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80942       };
80943     } catch (...) {
80944       {
80945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80946       };
80947     }
80948   }
80949
80950 }
80951
80952
80953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
80954   void * jresult ;
80955   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80956   Dali::Vector2 result;
80957
80958   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80959   {
80960     try {
80961       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
80962     } catch (std::out_of_range& e) {
80963       {
80964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80965       };
80966     } catch (std::exception& e) {
80967       {
80968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80969       };
80970     } catch (Dali::DaliException e) {
80971       {
80972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80973       };
80974     } catch (...) {
80975       {
80976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80977       };
80978     }
80979   }
80980
80981   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80982   return jresult;
80983 }
80984
80985
80986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
80987   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80988   Dali::Vector2 *arg2 = 0 ;
80989
80990   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80991   arg2 = (Dali::Vector2 *)jarg2;
80992   if (!arg2) {
80993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80994     return ;
80995   }
80996   {
80997     try {
80998       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
80999     } catch (std::out_of_range& e) {
81000       {
81001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81002       };
81003     } catch (std::exception& e) {
81004       {
81005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81006       };
81007     } catch (Dali::DaliException e) {
81008       {
81009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81010       };
81011     } catch (...) {
81012       {
81013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81014       };
81015     }
81016   }
81017
81018 }
81019
81020
81021 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
81022   float jresult ;
81023   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81024   float result;
81025
81026   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81027   {
81028     try {
81029       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
81030     } catch (std::out_of_range& e) {
81031       {
81032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81033       };
81034     } catch (std::exception& e) {
81035       {
81036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81037       };
81038     } catch (Dali::DaliException e) {
81039       {
81040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81041       };
81042     } catch (...) {
81043       {
81044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81045       };
81046     }
81047   }
81048
81049   jresult = result;
81050   return jresult;
81051 }
81052
81053
81054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
81055   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81056   float arg2 ;
81057
81058   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81059   arg2 = (float)jarg2;
81060   {
81061     try {
81062       (arg1)->SetMinimumSpeedForFlick(arg2);
81063     } catch (std::out_of_range& e) {
81064       {
81065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81066       };
81067     } catch (std::exception& e) {
81068       {
81069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81070       };
81071     } catch (Dali::DaliException e) {
81072       {
81073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81074       };
81075     } catch (...) {
81076       {
81077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81078       };
81079     }
81080   }
81081
81082 }
81083
81084
81085 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
81086   float jresult ;
81087   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81088   float result;
81089
81090   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81091   {
81092     try {
81093       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
81094     } catch (std::out_of_range& e) {
81095       {
81096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81097       };
81098     } catch (std::exception& e) {
81099       {
81100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81101       };
81102     } catch (Dali::DaliException e) {
81103       {
81104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81105       };
81106     } catch (...) {
81107       {
81108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81109       };
81110     }
81111   }
81112
81113   jresult = result;
81114   return jresult;
81115 }
81116
81117
81118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
81119   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81120   float arg2 ;
81121
81122   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81123   arg2 = (float)jarg2;
81124   {
81125     try {
81126       (arg1)->SetMaxFlickSpeed(arg2);
81127     } catch (std::out_of_range& e) {
81128       {
81129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81130       };
81131     } catch (std::exception& e) {
81132       {
81133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81134       };
81135     } catch (Dali::DaliException e) {
81136       {
81137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81138       };
81139     } catch (...) {
81140       {
81141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81142       };
81143     }
81144   }
81145
81146 }
81147
81148
81149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
81150   void * jresult ;
81151   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81152   Dali::Vector2 result;
81153
81154   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81155   {
81156     try {
81157       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
81158     } catch (std::out_of_range& e) {
81159       {
81160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81161       };
81162     } catch (std::exception& e) {
81163       {
81164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81165       };
81166     } catch (Dali::DaliException e) {
81167       {
81168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81169       };
81170     } catch (...) {
81171       {
81172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81173       };
81174     }
81175   }
81176
81177   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81178   return jresult;
81179 }
81180
81181
81182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
81183   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81184   Dali::Vector2 arg2 ;
81185   Dali::Vector2 *argp2 ;
81186
81187   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81188   argp2 = (Dali::Vector2 *)jarg2;
81189   if (!argp2) {
81190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
81191     return ;
81192   }
81193   arg2 = *argp2;
81194   {
81195     try {
81196       (arg1)->SetWheelScrollDistanceStep(arg2);
81197     } catch (std::out_of_range& e) {
81198       {
81199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81200       };
81201     } catch (std::exception& e) {
81202       {
81203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81204       };
81205     } catch (Dali::DaliException e) {
81206       {
81207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81208       };
81209     } catch (...) {
81210       {
81211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81212       };
81213     }
81214   }
81215
81216 }
81217
81218
81219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
81220   void * jresult ;
81221   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81222   Dali::Vector2 result;
81223
81224   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81225   {
81226     try {
81227       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
81228     } catch (std::out_of_range& e) {
81229       {
81230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81231       };
81232     } catch (std::exception& e) {
81233       {
81234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81235       };
81236     } catch (Dali::DaliException e) {
81237       {
81238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81239       };
81240     } catch (...) {
81241       {
81242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81243       };
81244     }
81245   }
81246
81247   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81248   return jresult;
81249 }
81250
81251
81252 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
81253   unsigned int jresult ;
81254   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81255   unsigned int result;
81256
81257   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81258   {
81259     try {
81260       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
81261     } catch (std::out_of_range& e) {
81262       {
81263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81264       };
81265     } catch (std::exception& e) {
81266       {
81267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81268       };
81269     } catch (Dali::DaliException e) {
81270       {
81271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81272       };
81273     } catch (...) {
81274       {
81275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81276       };
81277     }
81278   }
81279
81280   jresult = result;
81281   return jresult;
81282 }
81283
81284
81285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
81286   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81287   Dali::Vector2 *arg2 = 0 ;
81288
81289   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81290   arg2 = (Dali::Vector2 *)jarg2;
81291   if (!arg2) {
81292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81293     return ;
81294   }
81295   {
81296     try {
81297       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
81298     } catch (std::out_of_range& e) {
81299       {
81300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81301       };
81302     } catch (std::exception& e) {
81303       {
81304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81305       };
81306     } catch (Dali::DaliException e) {
81307       {
81308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81309       };
81310     } catch (...) {
81311       {
81312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81313       };
81314     }
81315   }
81316
81317 }
81318
81319
81320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
81321   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81322   Dali::Vector2 *arg2 = 0 ;
81323   float arg3 ;
81324
81325   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81326   arg2 = (Dali::Vector2 *)jarg2;
81327   if (!arg2) {
81328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81329     return ;
81330   }
81331   arg3 = (float)jarg3;
81332   {
81333     try {
81334       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
81335     } catch (std::out_of_range& e) {
81336       {
81337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81338       };
81339     } catch (std::exception& e) {
81340       {
81341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81342       };
81343     } catch (Dali::DaliException e) {
81344       {
81345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81346       };
81347     } catch (...) {
81348       {
81349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81350       };
81351     }
81352   }
81353
81354 }
81355
81356
81357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
81358   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81359   Dali::Vector2 *arg2 = 0 ;
81360   float arg3 ;
81361   Dali::AlphaFunction arg4 ;
81362   Dali::AlphaFunction *argp4 ;
81363
81364   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81365   arg2 = (Dali::Vector2 *)jarg2;
81366   if (!arg2) {
81367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81368     return ;
81369   }
81370   arg3 = (float)jarg3;
81371   argp4 = (Dali::AlphaFunction *)jarg4;
81372   if (!argp4) {
81373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81374     return ;
81375   }
81376   arg4 = *argp4;
81377   {
81378     try {
81379       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
81380     } catch (std::out_of_range& e) {
81381       {
81382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81383       };
81384     } catch (std::exception& e) {
81385       {
81386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81387       };
81388     } catch (Dali::DaliException e) {
81389       {
81390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81391       };
81392     } catch (...) {
81393       {
81394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81395       };
81396     }
81397   }
81398
81399 }
81400
81401
81402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
81403   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81404   Dali::Vector2 *arg2 = 0 ;
81405   float arg3 ;
81406   Dali::Toolkit::DirectionBias arg4 ;
81407   Dali::Toolkit::DirectionBias arg5 ;
81408
81409   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81410   arg2 = (Dali::Vector2 *)jarg2;
81411   if (!arg2) {
81412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81413     return ;
81414   }
81415   arg3 = (float)jarg3;
81416   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81417   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81418   {
81419     try {
81420       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
81421     } catch (std::out_of_range& e) {
81422       {
81423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81424       };
81425     } catch (std::exception& e) {
81426       {
81427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81428       };
81429     } catch (Dali::DaliException e) {
81430       {
81431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81432       };
81433     } catch (...) {
81434       {
81435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81436       };
81437     }
81438   }
81439
81440 }
81441
81442
81443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
81444   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81445   Dali::Vector2 *arg2 = 0 ;
81446   float arg3 ;
81447   Dali::AlphaFunction arg4 ;
81448   Dali::Toolkit::DirectionBias arg5 ;
81449   Dali::Toolkit::DirectionBias arg6 ;
81450   Dali::AlphaFunction *argp4 ;
81451
81452   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81453   arg2 = (Dali::Vector2 *)jarg2;
81454   if (!arg2) {
81455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81456     return ;
81457   }
81458   arg3 = (float)jarg3;
81459   argp4 = (Dali::AlphaFunction *)jarg4;
81460   if (!argp4) {
81461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81462     return ;
81463   }
81464   arg4 = *argp4;
81465   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81466   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
81467   {
81468     try {
81469       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
81470     } catch (std::out_of_range& e) {
81471       {
81472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81473       };
81474     } catch (std::exception& e) {
81475       {
81476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81477       };
81478     } catch (Dali::DaliException e) {
81479       {
81480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81481       };
81482     } catch (...) {
81483       {
81484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81485       };
81486     }
81487   }
81488
81489 }
81490
81491
81492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
81493   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81494   unsigned int arg2 ;
81495
81496   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81497   arg2 = (unsigned int)jarg2;
81498   {
81499     try {
81500       (arg1)->ScrollTo(arg2);
81501     } catch (std::out_of_range& e) {
81502       {
81503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81504       };
81505     } catch (std::exception& e) {
81506       {
81507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81508       };
81509     } catch (Dali::DaliException e) {
81510       {
81511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81512       };
81513     } catch (...) {
81514       {
81515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81516       };
81517     }
81518   }
81519
81520 }
81521
81522
81523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
81524   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81525   unsigned int arg2 ;
81526   float arg3 ;
81527
81528   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81529   arg2 = (unsigned int)jarg2;
81530   arg3 = (float)jarg3;
81531   {
81532     try {
81533       (arg1)->ScrollTo(arg2,arg3);
81534     } catch (std::out_of_range& e) {
81535       {
81536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81537       };
81538     } catch (std::exception& e) {
81539       {
81540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81541       };
81542     } catch (Dali::DaliException e) {
81543       {
81544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81545       };
81546     } catch (...) {
81547       {
81548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81549       };
81550     }
81551   }
81552
81553 }
81554
81555
81556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
81557   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81558   unsigned int arg2 ;
81559   float arg3 ;
81560   Dali::Toolkit::DirectionBias arg4 ;
81561
81562   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81563   arg2 = (unsigned int)jarg2;
81564   arg3 = (float)jarg3;
81565   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81566   {
81567     try {
81568       (arg1)->ScrollTo(arg2,arg3,arg4);
81569     } catch (std::out_of_range& e) {
81570       {
81571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81572       };
81573     } catch (std::exception& e) {
81574       {
81575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81576       };
81577     } catch (Dali::DaliException e) {
81578       {
81579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81580       };
81581     } catch (...) {
81582       {
81583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81584       };
81585     }
81586   }
81587
81588 }
81589
81590
81591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
81592   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81593   Dali::Actor *arg2 = 0 ;
81594
81595   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81596   arg2 = (Dali::Actor *)jarg2;
81597   if (!arg2) {
81598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
81599     return ;
81600   }
81601   {
81602     try {
81603       (arg1)->ScrollTo(*arg2);
81604     } catch (std::out_of_range& e) {
81605       {
81606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81607       };
81608     } catch (std::exception& e) {
81609       {
81610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81611       };
81612     } catch (Dali::DaliException e) {
81613       {
81614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81615       };
81616     } catch (...) {
81617       {
81618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81619       };
81620     }
81621   }
81622
81623 }
81624
81625
81626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
81627   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81628   Dali::Actor *arg2 = 0 ;
81629   float arg3 ;
81630
81631   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81632   arg2 = (Dali::Actor *)jarg2;
81633   if (!arg2) {
81634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
81635     return ;
81636   }
81637   arg3 = (float)jarg3;
81638   {
81639     try {
81640       (arg1)->ScrollTo(*arg2,arg3);
81641     } catch (std::out_of_range& e) {
81642       {
81643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81644       };
81645     } catch (std::exception& e) {
81646       {
81647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81648       };
81649     } catch (Dali::DaliException e) {
81650       {
81651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81652       };
81653     } catch (...) {
81654       {
81655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81656       };
81657     }
81658   }
81659
81660 }
81661
81662
81663 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
81664   unsigned int jresult ;
81665   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81666   bool result;
81667
81668   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81669   {
81670     try {
81671       result = (bool)(arg1)->ScrollToSnapPoint();
81672     } catch (std::out_of_range& e) {
81673       {
81674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81675       };
81676     } catch (std::exception& e) {
81677       {
81678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81679       };
81680     } catch (Dali::DaliException e) {
81681       {
81682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81683       };
81684     } catch (...) {
81685       {
81686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81687       };
81688     }
81689   }
81690
81691   jresult = result;
81692   return jresult;
81693 }
81694
81695
81696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
81697   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81698   Dali::Constraint arg2 ;
81699   Dali::Constraint *argp2 ;
81700
81701   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81702   argp2 = (Dali::Constraint *)jarg2;
81703   if (!argp2) {
81704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
81705     return ;
81706   }
81707   arg2 = *argp2;
81708   {
81709     try {
81710       (arg1)->ApplyConstraintToChildren(arg2);
81711     } catch (std::out_of_range& e) {
81712       {
81713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81714       };
81715     } catch (std::exception& e) {
81716       {
81717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81718       };
81719     } catch (Dali::DaliException e) {
81720       {
81721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81722       };
81723     } catch (...) {
81724       {
81725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81726       };
81727     }
81728   }
81729
81730 }
81731
81732
81733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
81734   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81735
81736   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81737   {
81738     try {
81739       (arg1)->RemoveConstraintsFromChildren();
81740     } catch (std::out_of_range& e) {
81741       {
81742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81743       };
81744     } catch (std::exception& e) {
81745       {
81746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81747       };
81748     } catch (Dali::DaliException e) {
81749       {
81750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81751       };
81752     } catch (...) {
81753       {
81754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81755       };
81756     }
81757   }
81758
81759 }
81760
81761
81762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
81763   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81764   Dali::Toolkit::ScrollViewEffect arg2 ;
81765   Dali::Toolkit::ScrollViewEffect *argp2 ;
81766
81767   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81768   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
81769   if (!argp2) {
81770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
81771     return ;
81772   }
81773   arg2 = *argp2;
81774   {
81775     try {
81776       (arg1)->ApplyEffect(arg2);
81777     } catch (std::out_of_range& e) {
81778       {
81779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81780       };
81781     } catch (std::exception& e) {
81782       {
81783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81784       };
81785     } catch (Dali::DaliException e) {
81786       {
81787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81788       };
81789     } catch (...) {
81790       {
81791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81792       };
81793     }
81794   }
81795
81796 }
81797
81798
81799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
81800   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81801   Dali::Toolkit::ScrollViewEffect arg2 ;
81802   Dali::Toolkit::ScrollViewEffect *argp2 ;
81803
81804   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81805   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
81806   if (!argp2) {
81807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
81808     return ;
81809   }
81810   arg2 = *argp2;
81811   {
81812     try {
81813       (arg1)->RemoveEffect(arg2);
81814     } catch (std::out_of_range& e) {
81815       {
81816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81817       };
81818     } catch (std::exception& e) {
81819       {
81820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81821       };
81822     } catch (Dali::DaliException e) {
81823       {
81824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81825       };
81826     } catch (...) {
81827       {
81828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81829       };
81830     }
81831   }
81832
81833 }
81834
81835
81836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
81837   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81838
81839   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81840   {
81841     try {
81842       (arg1)->RemoveAllEffects();
81843     } catch (std::out_of_range& e) {
81844       {
81845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81846       };
81847     } catch (std::exception& e) {
81848       {
81849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81850       };
81851     } catch (Dali::DaliException e) {
81852       {
81853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81854       };
81855     } catch (...) {
81856       {
81857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81858       };
81859     }
81860   }
81861
81862 }
81863
81864
81865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
81866   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81867   Dali::Actor arg2 ;
81868   Dali::Actor *argp2 ;
81869
81870   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81871   argp2 = (Dali::Actor *)jarg2;
81872   if (!argp2) {
81873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81874     return ;
81875   }
81876   arg2 = *argp2;
81877   {
81878     try {
81879       (arg1)->BindActor(arg2);
81880     } catch (std::out_of_range& e) {
81881       {
81882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81883       };
81884     } catch (std::exception& e) {
81885       {
81886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81887       };
81888     } catch (Dali::DaliException e) {
81889       {
81890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81891       };
81892     } catch (...) {
81893       {
81894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81895       };
81896     }
81897   }
81898
81899 }
81900
81901
81902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
81903   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81904   Dali::Actor arg2 ;
81905   Dali::Actor *argp2 ;
81906
81907   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81908   argp2 = (Dali::Actor *)jarg2;
81909   if (!argp2) {
81910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81911     return ;
81912   }
81913   arg2 = *argp2;
81914   {
81915     try {
81916       (arg1)->UnbindActor(arg2);
81917     } catch (std::out_of_range& e) {
81918       {
81919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81920       };
81921     } catch (std::exception& e) {
81922       {
81923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81924       };
81925     } catch (Dali::DaliException e) {
81926       {
81927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81928       };
81929     } catch (...) {
81930       {
81931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81932       };
81933     }
81934   }
81935
81936 }
81937
81938
81939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
81940   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81941   Dali::Radian arg2 ;
81942   Dali::Radian arg3 ;
81943   Dali::Radian *argp2 ;
81944   Dali::Radian *argp3 ;
81945
81946   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81947   argp2 = (Dali::Radian *)jarg2;
81948   if (!argp2) {
81949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81950     return ;
81951   }
81952   arg2 = *argp2;
81953   argp3 = (Dali::Radian *)jarg3;
81954   if (!argp3) {
81955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81956     return ;
81957   }
81958   arg3 = *argp3;
81959   {
81960     try {
81961       (arg1)->SetScrollingDirection(arg2,arg3);
81962     } catch (std::out_of_range& e) {
81963       {
81964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81965       };
81966     } catch (std::exception& e) {
81967       {
81968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81969       };
81970     } catch (Dali::DaliException e) {
81971       {
81972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81973       };
81974     } catch (...) {
81975       {
81976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81977       };
81978     }
81979   }
81980
81981 }
81982
81983
81984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
81985   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81986   Dali::Radian arg2 ;
81987   Dali::Radian *argp2 ;
81988
81989   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81990   argp2 = (Dali::Radian *)jarg2;
81991   if (!argp2) {
81992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81993     return ;
81994   }
81995   arg2 = *argp2;
81996   {
81997     try {
81998       (arg1)->SetScrollingDirection(arg2);
81999     } catch (std::out_of_range& e) {
82000       {
82001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82002       };
82003     } catch (std::exception& e) {
82004       {
82005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82006       };
82007     } catch (Dali::DaliException e) {
82008       {
82009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82010       };
82011     } catch (...) {
82012       {
82013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82014       };
82015     }
82016   }
82017
82018 }
82019
82020
82021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
82022   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82023   Dali::Radian arg2 ;
82024   Dali::Radian *argp2 ;
82025
82026   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82027   argp2 = (Dali::Radian *)jarg2;
82028   if (!argp2) {
82029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82030     return ;
82031   }
82032   arg2 = *argp2;
82033   {
82034     try {
82035       (arg1)->RemoveScrollingDirection(arg2);
82036     } catch (std::out_of_range& e) {
82037       {
82038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82039       };
82040     } catch (std::exception& e) {
82041       {
82042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82043       };
82044     } catch (Dali::DaliException e) {
82045       {
82046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82047       };
82048     } catch (...) {
82049       {
82050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82051       };
82052     }
82053   }
82054
82055 }
82056
82057
82058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
82059   void * jresult ;
82060   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82061   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
82062
82063   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82064   {
82065     try {
82066       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
82067     } catch (std::out_of_range& e) {
82068       {
82069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82070       };
82071     } catch (std::exception& e) {
82072       {
82073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82074       };
82075     } catch (Dali::DaliException e) {
82076       {
82077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82078       };
82079     } catch (...) {
82080       {
82081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82082       };
82083     }
82084   }
82085
82086   jresult = (void *)result;
82087   return jresult;
82088 }
82089
82090
82091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
82092   int jresult ;
82093   int result;
82094
82095   result = (int)Dali::Toolkit::TableView::Property::ROWS;
82096   jresult = (int)result;
82097   return jresult;
82098 }
82099
82100
82101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
82102   int jresult ;
82103   int result;
82104
82105   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
82106   jresult = (int)result;
82107   return jresult;
82108 }
82109
82110
82111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
82112   int jresult ;
82113   int result;
82114
82115   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
82116   jresult = (int)result;
82117   return jresult;
82118 }
82119
82120
82121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
82122   int jresult ;
82123   int result;
82124
82125   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
82126   jresult = (int)result;
82127   return jresult;
82128 }
82129
82130
82131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
82132   int jresult ;
82133   int result;
82134
82135   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
82136   jresult = (int)result;
82137   return jresult;
82138 }
82139
82140
82141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
82142   void * jresult ;
82143   Dali::Toolkit::TableView::Property *result = 0 ;
82144
82145   {
82146     try {
82147       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
82148     } catch (std::out_of_range& e) {
82149       {
82150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82151       };
82152     } catch (std::exception& e) {
82153       {
82154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82155       };
82156     } catch (Dali::DaliException e) {
82157       {
82158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82159       };
82160     } catch (...) {
82161       {
82162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82163       };
82164     }
82165   }
82166
82167   jresult = (void *)result;
82168   return jresult;
82169 }
82170
82171
82172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
82173   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
82174
82175   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
82176   {
82177     try {
82178       delete arg1;
82179     } catch (std::out_of_range& e) {
82180       {
82181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82182       };
82183     } catch (std::exception& e) {
82184       {
82185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82186       };
82187     } catch (Dali::DaliException e) {
82188       {
82189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82190       };
82191     } catch (...) {
82192       {
82193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82194       };
82195     }
82196   }
82197
82198 }
82199
82200
82201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
82202   int jresult ;
82203   int result;
82204
82205   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
82206   jresult = (int)result;
82207   return jresult;
82208 }
82209
82210
82211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
82212   int jresult ;
82213   int result;
82214
82215   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
82216   jresult = (int)result;
82217   return jresult;
82218 }
82219
82220
82221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
82222   int jresult ;
82223   int result;
82224
82225   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
82226   jresult = (int)result;
82227   return jresult;
82228 }
82229
82230
82231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
82232   int jresult ;
82233   int result;
82234
82235   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
82236   jresult = (int)result;
82237   return jresult;
82238 }
82239
82240
82241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
82242   int jresult ;
82243   int result;
82244
82245   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
82246   jresult = (int)result;
82247   return jresult;
82248 }
82249
82250
82251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
82252   void * jresult ;
82253   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
82254
82255   {
82256     try {
82257       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
82258     } catch (std::out_of_range& e) {
82259       {
82260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82261       };
82262     } catch (std::exception& e) {
82263       {
82264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82265       };
82266     } catch (Dali::DaliException e) {
82267       {
82268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82269       };
82270     } catch (...) {
82271       {
82272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82273       };
82274     }
82275   }
82276
82277   jresult = (void *)result;
82278   return jresult;
82279 }
82280
82281
82282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
82283   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
82284
82285   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
82286   {
82287     try {
82288       delete arg1;
82289     } catch (std::out_of_range& e) {
82290       {
82291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82292       };
82293     } catch (std::exception& e) {
82294       {
82295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82296       };
82297     } catch (Dali::DaliException e) {
82298       {
82299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82300       };
82301     } catch (...) {
82302       {
82303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82304       };
82305     }
82306   }
82307
82308 }
82309
82310
82311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
82312   void * jresult ;
82313   unsigned int arg1 ;
82314   unsigned int arg2 ;
82315   unsigned int arg3 ;
82316   unsigned int arg4 ;
82317   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82318
82319   arg1 = (unsigned int)jarg1;
82320   arg2 = (unsigned int)jarg2;
82321   arg3 = (unsigned int)jarg3;
82322   arg4 = (unsigned int)jarg4;
82323   {
82324     try {
82325       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
82326     } catch (std::out_of_range& e) {
82327       {
82328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82329       };
82330     } catch (std::exception& e) {
82331       {
82332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82333       };
82334     } catch (Dali::DaliException e) {
82335       {
82336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82337       };
82338     } catch (...) {
82339       {
82340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82341       };
82342     }
82343   }
82344
82345   jresult = (void *)result;
82346   return jresult;
82347 }
82348
82349
82350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
82351   void * jresult ;
82352   unsigned int arg1 ;
82353   unsigned int arg2 ;
82354   unsigned int arg3 ;
82355   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82356
82357   arg1 = (unsigned int)jarg1;
82358   arg2 = (unsigned int)jarg2;
82359   arg3 = (unsigned int)jarg3;
82360   {
82361     try {
82362       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
82363     } catch (std::out_of_range& e) {
82364       {
82365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82366       };
82367     } catch (std::exception& e) {
82368       {
82369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82370       };
82371     } catch (Dali::DaliException e) {
82372       {
82373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82374       };
82375     } catch (...) {
82376       {
82377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82378       };
82379     }
82380   }
82381
82382   jresult = (void *)result;
82383   return jresult;
82384 }
82385
82386
82387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
82388   void * jresult ;
82389   unsigned int arg1 ;
82390   unsigned int arg2 ;
82391   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82392
82393   arg1 = (unsigned int)jarg1;
82394   arg2 = (unsigned int)jarg2;
82395   {
82396     try {
82397       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
82398     } catch (std::out_of_range& e) {
82399       {
82400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82401       };
82402     } catch (std::exception& e) {
82403       {
82404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82405       };
82406     } catch (Dali::DaliException e) {
82407       {
82408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82409       };
82410     } catch (...) {
82411       {
82412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82413       };
82414     }
82415   }
82416
82417   jresult = (void *)result;
82418   return jresult;
82419 }
82420
82421
82422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
82423   void * jresult ;
82424   unsigned int arg1 ;
82425   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82426
82427   arg1 = (unsigned int)jarg1;
82428   {
82429     try {
82430       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
82431     } catch (std::out_of_range& e) {
82432       {
82433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82434       };
82435     } catch (std::exception& e) {
82436       {
82437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82438       };
82439     } catch (Dali::DaliException e) {
82440       {
82441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82442       };
82443     } catch (...) {
82444       {
82445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82446       };
82447     }
82448   }
82449
82450   jresult = (void *)result;
82451   return jresult;
82452 }
82453
82454
82455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
82456   void * jresult ;
82457   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82458
82459   {
82460     try {
82461       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
82462     } catch (std::out_of_range& e) {
82463       {
82464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82465       };
82466     } catch (std::exception& e) {
82467       {
82468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82469       };
82470     } catch (Dali::DaliException e) {
82471       {
82472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82473       };
82474     } catch (...) {
82475       {
82476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82477       };
82478     }
82479   }
82480
82481   jresult = (void *)result;
82482   return jresult;
82483 }
82484
82485
82486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
82487   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82488   unsigned int arg2 ;
82489
82490   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82491   arg2 = (unsigned int)jarg2;
82492   if (arg1) (arg1)->rowIndex = arg2;
82493 }
82494
82495
82496 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
82497   unsigned int jresult ;
82498   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82499   unsigned int result;
82500
82501   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82502   result = (unsigned int) ((arg1)->rowIndex);
82503   jresult = result;
82504   return jresult;
82505 }
82506
82507
82508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
82509   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82510   unsigned int arg2 ;
82511
82512   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82513   arg2 = (unsigned int)jarg2;
82514   if (arg1) (arg1)->columnIndex = arg2;
82515 }
82516
82517
82518 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
82519   unsigned int jresult ;
82520   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82521   unsigned int result;
82522
82523   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82524   result = (unsigned int) ((arg1)->columnIndex);
82525   jresult = result;
82526   return jresult;
82527 }
82528
82529
82530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
82531   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82532   unsigned int arg2 ;
82533
82534   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82535   arg2 = (unsigned int)jarg2;
82536   if (arg1) (arg1)->rowSpan = arg2;
82537 }
82538
82539
82540 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
82541   unsigned int jresult ;
82542   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82543   unsigned int result;
82544
82545   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82546   result = (unsigned int) ((arg1)->rowSpan);
82547   jresult = result;
82548   return jresult;
82549 }
82550
82551
82552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
82553   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82554   unsigned int arg2 ;
82555
82556   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82557   arg2 = (unsigned int)jarg2;
82558   if (arg1) (arg1)->columnSpan = arg2;
82559 }
82560
82561
82562 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
82563   unsigned int jresult ;
82564   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82565   unsigned int result;
82566
82567   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82568   result = (unsigned int) ((arg1)->columnSpan);
82569   jresult = result;
82570   return jresult;
82571 }
82572
82573
82574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
82575   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82576
82577   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82578   {
82579     try {
82580       delete arg1;
82581     } catch (std::out_of_range& e) {
82582       {
82583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82584       };
82585     } catch (std::exception& e) {
82586       {
82587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82588       };
82589     } catch (Dali::DaliException e) {
82590       {
82591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82592       };
82593     } catch (...) {
82594       {
82595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82596       };
82597     }
82598   }
82599
82600 }
82601
82602
82603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
82604   void * jresult ;
82605   Dali::Toolkit::TableView *result = 0 ;
82606
82607   {
82608     try {
82609       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
82610     } catch (std::out_of_range& e) {
82611       {
82612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82613       };
82614     } catch (std::exception& e) {
82615       {
82616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82617       };
82618     } catch (Dali::DaliException e) {
82619       {
82620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82621       };
82622     } catch (...) {
82623       {
82624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82625       };
82626     }
82627   }
82628
82629   jresult = (void *)result;
82630   return jresult;
82631 }
82632
82633
82634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
82635   void * jresult ;
82636   Dali::Toolkit::TableView *arg1 = 0 ;
82637   Dali::Toolkit::TableView *result = 0 ;
82638
82639   arg1 = (Dali::Toolkit::TableView *)jarg1;
82640   if (!arg1) {
82641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
82642     return 0;
82643   }
82644   {
82645     try {
82646       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
82647     } catch (std::out_of_range& e) {
82648       {
82649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82650       };
82651     } catch (std::exception& e) {
82652       {
82653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82654       };
82655     } catch (Dali::DaliException e) {
82656       {
82657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82658       };
82659     } catch (...) {
82660       {
82661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82662       };
82663     }
82664   }
82665
82666   jresult = (void *)result;
82667   return jresult;
82668 }
82669
82670
82671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
82672   void * jresult ;
82673   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82674   Dali::Toolkit::TableView *arg2 = 0 ;
82675   Dali::Toolkit::TableView *result = 0 ;
82676
82677   arg1 = (Dali::Toolkit::TableView *)jarg1;
82678   arg2 = (Dali::Toolkit::TableView *)jarg2;
82679   if (!arg2) {
82680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
82681     return 0;
82682   }
82683   {
82684     try {
82685       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
82686     } catch (std::out_of_range& e) {
82687       {
82688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82689       };
82690     } catch (std::exception& e) {
82691       {
82692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82693       };
82694     } catch (Dali::DaliException e) {
82695       {
82696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82697       };
82698     } catch (...) {
82699       {
82700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82701       };
82702     }
82703   }
82704
82705   jresult = (void *)result;
82706   return jresult;
82707 }
82708
82709
82710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
82711   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82712
82713   arg1 = (Dali::Toolkit::TableView *)jarg1;
82714   {
82715     try {
82716       delete arg1;
82717     } catch (std::out_of_range& e) {
82718       {
82719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82720       };
82721     } catch (std::exception& e) {
82722       {
82723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82724       };
82725     } catch (Dali::DaliException e) {
82726       {
82727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82728       };
82729     } catch (...) {
82730       {
82731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82732       };
82733     }
82734   }
82735
82736 }
82737
82738
82739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
82740   void * jresult ;
82741   unsigned int arg1 ;
82742   unsigned int arg2 ;
82743   Dali::Toolkit::TableView result;
82744
82745   arg1 = (unsigned int)jarg1;
82746   arg2 = (unsigned int)jarg2;
82747   {
82748     try {
82749       result = Dali::Toolkit::TableView::New(arg1,arg2);
82750     } catch (std::out_of_range& e) {
82751       {
82752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82753       };
82754     } catch (std::exception& e) {
82755       {
82756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82757       };
82758     } catch (Dali::DaliException e) {
82759       {
82760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82761       };
82762     } catch (...) {
82763       {
82764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82765       };
82766     }
82767   }
82768
82769   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
82770   return jresult;
82771 }
82772
82773
82774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
82775   void * jresult ;
82776   Dali::BaseHandle arg1 ;
82777   Dali::BaseHandle *argp1 ;
82778   Dali::Toolkit::TableView result;
82779
82780   argp1 = (Dali::BaseHandle *)jarg1;
82781   if (!argp1) {
82782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82783     return 0;
82784   }
82785   arg1 = *argp1;
82786   {
82787     try {
82788       result = Dali::Toolkit::TableView::DownCast(arg1);
82789     } catch (std::out_of_range& e) {
82790       {
82791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82792       };
82793     } catch (std::exception& e) {
82794       {
82795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82796       };
82797     } catch (Dali::DaliException e) {
82798       {
82799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82800       };
82801     } catch (...) {
82802       {
82803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82804       };
82805     }
82806   }
82807
82808   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
82809   return jresult;
82810 }
82811
82812
82813 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
82814   unsigned int jresult ;
82815   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82816   Dali::Actor arg2 ;
82817   Dali::Toolkit::TableView::CellPosition arg3 ;
82818   Dali::Actor *argp2 ;
82819   Dali::Toolkit::TableView::CellPosition *argp3 ;
82820   bool result;
82821
82822   arg1 = (Dali::Toolkit::TableView *)jarg1;
82823   argp2 = (Dali::Actor *)jarg2;
82824   if (!argp2) {
82825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82826     return 0;
82827   }
82828   arg2 = *argp2;
82829   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
82830   if (!argp3) {
82831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82832     return 0;
82833   }
82834   arg3 = *argp3;
82835   {
82836     try {
82837       result = (bool)(arg1)->AddChild(arg2,arg3);
82838     } catch (std::out_of_range& e) {
82839       {
82840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82841       };
82842     } catch (std::exception& e) {
82843       {
82844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82845       };
82846     } catch (Dali::DaliException e) {
82847       {
82848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82849       };
82850     } catch (...) {
82851       {
82852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82853       };
82854     }
82855   }
82856
82857   jresult = result;
82858   return jresult;
82859 }
82860
82861
82862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
82863   void * jresult ;
82864   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82865   Dali::Toolkit::TableView::CellPosition arg2 ;
82866   Dali::Toolkit::TableView::CellPosition *argp2 ;
82867   Dali::Actor result;
82868
82869   arg1 = (Dali::Toolkit::TableView *)jarg1;
82870   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
82871   if (!argp2) {
82872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82873     return 0;
82874   }
82875   arg2 = *argp2;
82876   {
82877     try {
82878       result = (arg1)->GetChildAt(arg2);
82879     } catch (std::out_of_range& e) {
82880       {
82881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82882       };
82883     } catch (std::exception& e) {
82884       {
82885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82886       };
82887     } catch (Dali::DaliException e) {
82888       {
82889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82890       };
82891     } catch (...) {
82892       {
82893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82894       };
82895     }
82896   }
82897
82898   jresult = new Dali::Actor((const Dali::Actor &)result);
82899   return jresult;
82900 }
82901
82902
82903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
82904   void * jresult ;
82905   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82906   Dali::Toolkit::TableView::CellPosition arg2 ;
82907   Dali::Toolkit::TableView::CellPosition *argp2 ;
82908   Dali::Actor result;
82909
82910   arg1 = (Dali::Toolkit::TableView *)jarg1;
82911   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
82912   if (!argp2) {
82913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82914     return 0;
82915   }
82916   arg2 = *argp2;
82917   {
82918     try {
82919       result = (arg1)->RemoveChildAt(arg2);
82920     } catch (std::out_of_range& e) {
82921       {
82922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82923       };
82924     } catch (std::exception& e) {
82925       {
82926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82927       };
82928     } catch (Dali::DaliException e) {
82929       {
82930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82931       };
82932     } catch (...) {
82933       {
82934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82935       };
82936     }
82937   }
82938
82939   jresult = new Dali::Actor((const Dali::Actor &)result);
82940   return jresult;
82941 }
82942
82943
82944 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
82945   unsigned int jresult ;
82946   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82947   Dali::Actor arg2 ;
82948   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
82949   Dali::Actor *argp2 ;
82950   bool result;
82951
82952   arg1 = (Dali::Toolkit::TableView *)jarg1;
82953   argp2 = (Dali::Actor *)jarg2;
82954   if (!argp2) {
82955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82956     return 0;
82957   }
82958   arg2 = *argp2;
82959   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
82960   if (!arg3) {
82961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
82962     return 0;
82963   }
82964   {
82965     try {
82966       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
82967     } catch (std::out_of_range& e) {
82968       {
82969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82970       };
82971     } catch (std::exception& e) {
82972       {
82973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82974       };
82975     } catch (Dali::DaliException e) {
82976       {
82977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82978       };
82979     } catch (...) {
82980       {
82981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82982       };
82983     }
82984   }
82985
82986   jresult = result;
82987   return jresult;
82988 }
82989
82990
82991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
82992   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82993   unsigned int arg2 ;
82994
82995   arg1 = (Dali::Toolkit::TableView *)jarg1;
82996   arg2 = (unsigned int)jarg2;
82997   {
82998     try {
82999       (arg1)->InsertRow(arg2);
83000     } catch (std::out_of_range& e) {
83001       {
83002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83003       };
83004     } catch (std::exception& e) {
83005       {
83006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83007       };
83008     } catch (Dali::DaliException e) {
83009       {
83010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83011       };
83012     } catch (...) {
83013       {
83014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83015       };
83016     }
83017   }
83018
83019 }
83020
83021
83022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
83023   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83024   unsigned int arg2 ;
83025
83026   arg1 = (Dali::Toolkit::TableView *)jarg1;
83027   arg2 = (unsigned int)jarg2;
83028   {
83029     try {
83030       (arg1)->DeleteRow(arg2);
83031     } catch (std::out_of_range& e) {
83032       {
83033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83034       };
83035     } catch (std::exception& e) {
83036       {
83037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83038       };
83039     } catch (Dali::DaliException e) {
83040       {
83041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83042       };
83043     } catch (...) {
83044       {
83045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83046       };
83047     }
83048   }
83049
83050 }
83051
83052
83053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
83054   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83055   unsigned int arg2 ;
83056   std::vector< Dali::Actor > *arg3 = 0 ;
83057
83058   arg1 = (Dali::Toolkit::TableView *)jarg1;
83059   arg2 = (unsigned int)jarg2;
83060   arg3 = (std::vector< Dali::Actor > *)jarg3;
83061   if (!arg3) {
83062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83063     return ;
83064   }
83065   {
83066     try {
83067       (arg1)->DeleteRow(arg2,*arg3);
83068     } catch (std::out_of_range& e) {
83069       {
83070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83071       };
83072     } catch (std::exception& e) {
83073       {
83074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83075       };
83076     } catch (Dali::DaliException e) {
83077       {
83078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83079       };
83080     } catch (...) {
83081       {
83082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83083       };
83084     }
83085   }
83086
83087 }
83088
83089
83090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
83091   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83092   unsigned int arg2 ;
83093
83094   arg1 = (Dali::Toolkit::TableView *)jarg1;
83095   arg2 = (unsigned int)jarg2;
83096   {
83097     try {
83098       (arg1)->InsertColumn(arg2);
83099     } catch (std::out_of_range& e) {
83100       {
83101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83102       };
83103     } catch (std::exception& e) {
83104       {
83105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83106       };
83107     } catch (Dali::DaliException e) {
83108       {
83109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83110       };
83111     } catch (...) {
83112       {
83113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83114       };
83115     }
83116   }
83117
83118 }
83119
83120
83121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
83122   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83123   unsigned int arg2 ;
83124
83125   arg1 = (Dali::Toolkit::TableView *)jarg1;
83126   arg2 = (unsigned int)jarg2;
83127   {
83128     try {
83129       (arg1)->DeleteColumn(arg2);
83130     } catch (std::out_of_range& e) {
83131       {
83132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83133       };
83134     } catch (std::exception& e) {
83135       {
83136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83137       };
83138     } catch (Dali::DaliException e) {
83139       {
83140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83141       };
83142     } catch (...) {
83143       {
83144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83145       };
83146     }
83147   }
83148
83149 }
83150
83151
83152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
83153   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83154   unsigned int arg2 ;
83155   std::vector< Dali::Actor > *arg3 = 0 ;
83156
83157   arg1 = (Dali::Toolkit::TableView *)jarg1;
83158   arg2 = (unsigned int)jarg2;
83159   arg3 = (std::vector< Dali::Actor > *)jarg3;
83160   if (!arg3) {
83161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83162     return ;
83163   }
83164   {
83165     try {
83166       (arg1)->DeleteColumn(arg2,*arg3);
83167     } catch (std::out_of_range& e) {
83168       {
83169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83170       };
83171     } catch (std::exception& e) {
83172       {
83173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83174       };
83175     } catch (Dali::DaliException e) {
83176       {
83177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83178       };
83179     } catch (...) {
83180       {
83181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83182       };
83183     }
83184   }
83185
83186 }
83187
83188
83189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
83190   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83191   unsigned int arg2 ;
83192   unsigned int arg3 ;
83193
83194   arg1 = (Dali::Toolkit::TableView *)jarg1;
83195   arg2 = (unsigned int)jarg2;
83196   arg3 = (unsigned int)jarg3;
83197   {
83198     try {
83199       (arg1)->Resize(arg2,arg3);
83200     } catch (std::out_of_range& e) {
83201       {
83202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83203       };
83204     } catch (std::exception& e) {
83205       {
83206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83207       };
83208     } catch (Dali::DaliException e) {
83209       {
83210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83211       };
83212     } catch (...) {
83213       {
83214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83215       };
83216     }
83217   }
83218
83219 }
83220
83221
83222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
83223   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83224   unsigned int arg2 ;
83225   unsigned int arg3 ;
83226   std::vector< Dali::Actor > *arg4 = 0 ;
83227
83228   arg1 = (Dali::Toolkit::TableView *)jarg1;
83229   arg2 = (unsigned int)jarg2;
83230   arg3 = (unsigned int)jarg3;
83231   arg4 = (std::vector< Dali::Actor > *)jarg4;
83232   if (!arg4) {
83233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83234     return ;
83235   }
83236   {
83237     try {
83238       (arg1)->Resize(arg2,arg3,*arg4);
83239     } catch (std::out_of_range& e) {
83240       {
83241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83242       };
83243     } catch (std::exception& e) {
83244       {
83245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83246       };
83247     } catch (Dali::DaliException e) {
83248       {
83249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83250       };
83251     } catch (...) {
83252       {
83253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83254       };
83255     }
83256   }
83257
83258 }
83259
83260
83261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
83262   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83263   Dali::Size arg2 ;
83264   Dali::Size *argp2 ;
83265
83266   arg1 = (Dali::Toolkit::TableView *)jarg1;
83267   argp2 = (Dali::Size *)jarg2;
83268   if (!argp2) {
83269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
83270     return ;
83271   }
83272   arg2 = *argp2;
83273   {
83274     try {
83275       (arg1)->SetCellPadding(arg2);
83276     } catch (std::out_of_range& e) {
83277       {
83278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83279       };
83280     } catch (std::exception& e) {
83281       {
83282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83283       };
83284     } catch (Dali::DaliException e) {
83285       {
83286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83287       };
83288     } catch (...) {
83289       {
83290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83291       };
83292     }
83293   }
83294
83295 }
83296
83297
83298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
83299   void * jresult ;
83300   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83301   Dali::Size result;
83302
83303   arg1 = (Dali::Toolkit::TableView *)jarg1;
83304   {
83305     try {
83306       result = (arg1)->GetCellPadding();
83307     } catch (std::out_of_range& e) {
83308       {
83309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83310       };
83311     } catch (std::exception& e) {
83312       {
83313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83314       };
83315     } catch (Dali::DaliException e) {
83316       {
83317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83318       };
83319     } catch (...) {
83320       {
83321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83322       };
83323     }
83324   }
83325
83326   jresult = new Dali::Size((const Dali::Size &)result);
83327   return jresult;
83328 }
83329
83330
83331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
83332   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83333   unsigned int arg2 ;
83334
83335   arg1 = (Dali::Toolkit::TableView *)jarg1;
83336   arg2 = (unsigned int)jarg2;
83337   {
83338     try {
83339       (arg1)->SetFitHeight(arg2);
83340     } catch (std::out_of_range& e) {
83341       {
83342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83343       };
83344     } catch (std::exception& e) {
83345       {
83346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83347       };
83348     } catch (Dali::DaliException e) {
83349       {
83350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83351       };
83352     } catch (...) {
83353       {
83354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83355       };
83356     }
83357   }
83358
83359 }
83360
83361
83362 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
83363   unsigned int jresult ;
83364   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83365   unsigned int arg2 ;
83366   bool result;
83367
83368   arg1 = (Dali::Toolkit::TableView *)jarg1;
83369   arg2 = (unsigned int)jarg2;
83370   {
83371     try {
83372       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
83373     } catch (std::out_of_range& e) {
83374       {
83375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83376       };
83377     } catch (std::exception& e) {
83378       {
83379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83380       };
83381     } catch (Dali::DaliException e) {
83382       {
83383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83384       };
83385     } catch (...) {
83386       {
83387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83388       };
83389     }
83390   }
83391
83392   jresult = result;
83393   return jresult;
83394 }
83395
83396
83397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
83398   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83399   unsigned int arg2 ;
83400
83401   arg1 = (Dali::Toolkit::TableView *)jarg1;
83402   arg2 = (unsigned int)jarg2;
83403   {
83404     try {
83405       (arg1)->SetFitWidth(arg2);
83406     } catch (std::out_of_range& e) {
83407       {
83408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83409       };
83410     } catch (std::exception& e) {
83411       {
83412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83413       };
83414     } catch (Dali::DaliException e) {
83415       {
83416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83417       };
83418     } catch (...) {
83419       {
83420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83421       };
83422     }
83423   }
83424
83425 }
83426
83427
83428 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
83429   unsigned int jresult ;
83430   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83431   unsigned int arg2 ;
83432   bool result;
83433
83434   arg1 = (Dali::Toolkit::TableView *)jarg1;
83435   arg2 = (unsigned int)jarg2;
83436   {
83437     try {
83438       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
83439     } catch (std::out_of_range& e) {
83440       {
83441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83442       };
83443     } catch (std::exception& e) {
83444       {
83445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83446       };
83447     } catch (Dali::DaliException e) {
83448       {
83449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83450       };
83451     } catch (...) {
83452       {
83453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83454       };
83455     }
83456   }
83457
83458   jresult = result;
83459   return jresult;
83460 }
83461
83462
83463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83464   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83465   unsigned int arg2 ;
83466   float arg3 ;
83467
83468   arg1 = (Dali::Toolkit::TableView *)jarg1;
83469   arg2 = (unsigned int)jarg2;
83470   arg3 = (float)jarg3;
83471   {
83472     try {
83473       (arg1)->SetFixedHeight(arg2,arg3);
83474     } catch (std::out_of_range& e) {
83475       {
83476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83477       };
83478     } catch (std::exception& e) {
83479       {
83480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83481       };
83482     } catch (Dali::DaliException e) {
83483       {
83484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83485       };
83486     } catch (...) {
83487       {
83488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83489       };
83490     }
83491   }
83492
83493 }
83494
83495
83496 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
83497   float jresult ;
83498   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83499   unsigned int arg2 ;
83500   float result;
83501
83502   arg1 = (Dali::Toolkit::TableView *)jarg1;
83503   arg2 = (unsigned int)jarg2;
83504   {
83505     try {
83506       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
83507     } catch (std::out_of_range& e) {
83508       {
83509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83510       };
83511     } catch (std::exception& e) {
83512       {
83513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83514       };
83515     } catch (Dali::DaliException e) {
83516       {
83517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83518       };
83519     } catch (...) {
83520       {
83521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83522       };
83523     }
83524   }
83525
83526   jresult = result;
83527   return jresult;
83528 }
83529
83530
83531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83532   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83533   unsigned int arg2 ;
83534   float arg3 ;
83535
83536   arg1 = (Dali::Toolkit::TableView *)jarg1;
83537   arg2 = (unsigned int)jarg2;
83538   arg3 = (float)jarg3;
83539   {
83540     try {
83541       (arg1)->SetRelativeHeight(arg2,arg3);
83542     } catch (std::out_of_range& e) {
83543       {
83544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83545       };
83546     } catch (std::exception& e) {
83547       {
83548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83549       };
83550     } catch (Dali::DaliException e) {
83551       {
83552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83553       };
83554     } catch (...) {
83555       {
83556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83557       };
83558     }
83559   }
83560
83561 }
83562
83563
83564 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
83565   float jresult ;
83566   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83567   unsigned int arg2 ;
83568   float result;
83569
83570   arg1 = (Dali::Toolkit::TableView *)jarg1;
83571   arg2 = (unsigned int)jarg2;
83572   {
83573     try {
83574       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
83575     } catch (std::out_of_range& e) {
83576       {
83577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83578       };
83579     } catch (std::exception& e) {
83580       {
83581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83582       };
83583     } catch (Dali::DaliException e) {
83584       {
83585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83586       };
83587     } catch (...) {
83588       {
83589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83590       };
83591     }
83592   }
83593
83594   jresult = result;
83595   return jresult;
83596 }
83597
83598
83599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
83600   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83601   unsigned int arg2 ;
83602   float arg3 ;
83603
83604   arg1 = (Dali::Toolkit::TableView *)jarg1;
83605   arg2 = (unsigned int)jarg2;
83606   arg3 = (float)jarg3;
83607   {
83608     try {
83609       (arg1)->SetFixedWidth(arg2,arg3);
83610     } catch (std::out_of_range& e) {
83611       {
83612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83613       };
83614     } catch (std::exception& e) {
83615       {
83616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83617       };
83618     } catch (Dali::DaliException e) {
83619       {
83620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83621       };
83622     } catch (...) {
83623       {
83624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83625       };
83626     }
83627   }
83628
83629 }
83630
83631
83632 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
83633   float jresult ;
83634   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83635   unsigned int arg2 ;
83636   float result;
83637
83638   arg1 = (Dali::Toolkit::TableView *)jarg1;
83639   arg2 = (unsigned int)jarg2;
83640   {
83641     try {
83642       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
83643     } catch (std::out_of_range& e) {
83644       {
83645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83646       };
83647     } catch (std::exception& e) {
83648       {
83649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83650       };
83651     } catch (Dali::DaliException e) {
83652       {
83653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83654       };
83655     } catch (...) {
83656       {
83657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83658       };
83659     }
83660   }
83661
83662   jresult = result;
83663   return jresult;
83664 }
83665
83666
83667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
83668   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83669   unsigned int arg2 ;
83670   float arg3 ;
83671
83672   arg1 = (Dali::Toolkit::TableView *)jarg1;
83673   arg2 = (unsigned int)jarg2;
83674   arg3 = (float)jarg3;
83675   {
83676     try {
83677       (arg1)->SetRelativeWidth(arg2,arg3);
83678     } catch (std::out_of_range& e) {
83679       {
83680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83681       };
83682     } catch (std::exception& e) {
83683       {
83684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83685       };
83686     } catch (Dali::DaliException e) {
83687       {
83688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83689       };
83690     } catch (...) {
83691       {
83692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83693       };
83694     }
83695   }
83696
83697 }
83698
83699
83700 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
83701   float jresult ;
83702   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83703   unsigned int arg2 ;
83704   float result;
83705
83706   arg1 = (Dali::Toolkit::TableView *)jarg1;
83707   arg2 = (unsigned int)jarg2;
83708   {
83709     try {
83710       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
83711     } catch (std::out_of_range& e) {
83712       {
83713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83714       };
83715     } catch (std::exception& e) {
83716       {
83717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83718       };
83719     } catch (Dali::DaliException e) {
83720       {
83721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83722       };
83723     } catch (...) {
83724       {
83725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83726       };
83727     }
83728   }
83729
83730   jresult = result;
83731   return jresult;
83732 }
83733
83734
83735 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
83736   unsigned int jresult ;
83737   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83738   unsigned int result;
83739
83740   arg1 = (Dali::Toolkit::TableView *)jarg1;
83741   {
83742     try {
83743       result = (unsigned int)(arg1)->GetRows();
83744     } catch (std::out_of_range& e) {
83745       {
83746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83747       };
83748     } catch (std::exception& e) {
83749       {
83750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83751       };
83752     } catch (Dali::DaliException e) {
83753       {
83754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83755       };
83756     } catch (...) {
83757       {
83758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83759       };
83760     }
83761   }
83762
83763   jresult = result;
83764   return jresult;
83765 }
83766
83767
83768 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
83769   unsigned int jresult ;
83770   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83771   unsigned int result;
83772
83773   arg1 = (Dali::Toolkit::TableView *)jarg1;
83774   {
83775     try {
83776       result = (unsigned int)(arg1)->GetColumns();
83777     } catch (std::out_of_range& e) {
83778       {
83779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83780       };
83781     } catch (std::exception& e) {
83782       {
83783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83784       };
83785     } catch (Dali::DaliException e) {
83786       {
83787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83788       };
83789     } catch (...) {
83790       {
83791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83792       };
83793     }
83794   }
83795
83796   jresult = result;
83797   return jresult;
83798 }
83799
83800
83801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
83802   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83803   Dali::Toolkit::TableView::CellPosition arg2 ;
83804   Dali::HorizontalAlignment::Type arg3 ;
83805   Dali::VerticalAlignment::Type arg4 ;
83806   Dali::Toolkit::TableView::CellPosition *argp2 ;
83807
83808   arg1 = (Dali::Toolkit::TableView *)jarg1;
83809   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
83810   if (!argp2) {
83811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83812     return ;
83813   }
83814   arg2 = *argp2;
83815   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
83816   arg4 = (Dali::VerticalAlignment::Type)jarg4;
83817   {
83818     try {
83819       (arg1)->SetCellAlignment(arg2,arg3,arg4);
83820     } catch (std::out_of_range& e) {
83821       {
83822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83823       };
83824     } catch (std::exception& e) {
83825       {
83826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83827       };
83828     } catch (Dali::DaliException e) {
83829       {
83830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83831       };
83832     } catch (...) {
83833       {
83834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83835       };
83836     }
83837   }
83838
83839 }
83840
83841
83842 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
83843   unsigned int jresult ;
83844   unsigned int result;
83845
83846   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
83847   jresult = result;
83848   return jresult;
83849 }
83850
83851
83852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
83853   int jresult ;
83854   int result;
83855
83856   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
83857   jresult = (int)result;
83858   return jresult;
83859 }
83860
83861
83862 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
83863   int jresult ;
83864   int result;
83865
83866   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
83867   jresult = (int)result;
83868   return jresult;
83869 }
83870
83871
83872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
83873   int jresult ;
83874   int result;
83875
83876   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
83877   jresult = (int)result;
83878   return jresult;
83879 }
83880
83881
83882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
83883   int jresult ;
83884   int result;
83885
83886   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
83887   jresult = (int)result;
83888   return jresult;
83889 }
83890
83891
83892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
83893   int jresult ;
83894   int result;
83895
83896   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
83897   jresult = (int)result;
83898   return jresult;
83899 }
83900
83901
83902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
83903   int jresult ;
83904   int result;
83905
83906   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
83907   jresult = (int)result;
83908   return jresult;
83909 }
83910
83911
83912 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
83913   int jresult ;
83914   int result;
83915
83916   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
83917   jresult = (int)result;
83918   return jresult;
83919 }
83920
83921
83922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
83923   int jresult ;
83924   int result;
83925
83926   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
83927   jresult = (int)result;
83928   return jresult;
83929 }
83930
83931
83932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
83933   int jresult ;
83934   int result;
83935
83936   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
83937   jresult = (int)result;
83938   return jresult;
83939 }
83940
83941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
83942   int jresult ;
83943   int result;
83944
83945   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
83946   jresult = (int)result;
83947   return jresult;
83948 }
83949
83950
83951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
83952   int jresult ;
83953   int result;
83954
83955   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
83956   jresult = (int)result;
83957   return jresult;
83958 }
83959
83960
83961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
83962   int jresult ;
83963   int result;
83964
83965   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
83966   jresult = (int)result;
83967   return jresult;
83968 }
83969
83970
83971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
83972   int jresult ;
83973   int result;
83974
83975   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
83976   jresult = (int)result;
83977   return jresult;
83978 }
83979
83980
83981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
83982   int jresult ;
83983   int result;
83984
83985   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
83986   jresult = (int)result;
83987   return jresult;
83988 }
83989
83990
83991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
83992   int jresult ;
83993   int result;
83994
83995   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
83996   jresult = (int)result;
83997   return jresult;
83998 }
83999
84000
84001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
84002   int jresult ;
84003   int result;
84004
84005   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
84006   jresult = (int)result;
84007   return jresult;
84008 }
84009
84010
84011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
84012   int jresult ;
84013   int result;
84014
84015   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
84016   jresult = (int)result;
84017   return jresult;
84018 }
84019
84020
84021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
84022   int jresult ;
84023   int result;
84024
84025   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
84026   jresult = (int)result;
84027   return jresult;
84028 }
84029
84030
84031 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
84032   int jresult ;
84033   int result;
84034
84035   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
84036   jresult = (int)result;
84037   return jresult;
84038 }
84039
84040
84041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
84042   int jresult ;
84043   int result;
84044
84045   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
84046   jresult = (int)result;
84047   return jresult;
84048 }
84049
84050
84051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
84052   int jresult ;
84053   int result;
84054
84055   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
84056   jresult = (int)result;
84057   return jresult;
84058 }
84059
84060
84061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
84062   int jresult ;
84063   int result;
84064
84065   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
84066   jresult = (int)result;
84067   return jresult;
84068 }
84069
84070
84071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
84072   int jresult ;
84073   int result;
84074
84075   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
84076   jresult = (int)result;
84077   return jresult;
84078 }
84079
84080
84081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
84082   int jresult ;
84083   int result;
84084
84085   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
84086   jresult = (int)result;
84087   return jresult;
84088 }
84089
84090
84091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
84092   void * jresult ;
84093   Dali::Toolkit::TextLabel::Property *result = 0 ;
84094
84095   {
84096     try {
84097       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
84098     } catch (std::out_of_range& e) {
84099       {
84100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84101       };
84102     } catch (std::exception& e) {
84103       {
84104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84105       };
84106     } catch (Dali::DaliException e) {
84107       {
84108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84109       };
84110     } catch (...) {
84111       {
84112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84113       };
84114     }
84115   }
84116
84117   jresult = (void *)result;
84118   return jresult;
84119 }
84120
84121
84122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
84123   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
84124
84125   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
84126   {
84127     try {
84128       delete arg1;
84129     } catch (std::out_of_range& e) {
84130       {
84131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84132       };
84133     } catch (std::exception& e) {
84134       {
84135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84136       };
84137     } catch (Dali::DaliException e) {
84138       {
84139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84140       };
84141     } catch (...) {
84142       {
84143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84144       };
84145     }
84146   }
84147
84148 }
84149
84150
84151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
84152   void * jresult ;
84153   Dali::Toolkit::TextLabel result;
84154
84155   {
84156     try {
84157       result = Dali::Toolkit::TextLabel::New();
84158
84159       // default behaviour of NUI TextLabel
84160       result.SetProperty( Dali::Toolkit::DevelTextLabel::Property::VERTICAL_LINE_ALIGNMENT, Dali::Toolkit::DevelText::VerticalLineAlignment::MIDDLE );
84161     } catch (std::out_of_range& e) {
84162       {
84163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84164       };
84165     } catch (std::exception& e) {
84166       {
84167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84168       };
84169     } catch (Dali::DaliException e) {
84170       {
84171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84172       };
84173     } catch (...) {
84174       {
84175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84176       };
84177     }
84178   }
84179
84180   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84181   return jresult;
84182 }
84183
84184
84185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
84186   void * jresult ;
84187   std::string *arg1 = 0 ;
84188   Dali::Toolkit::TextLabel result;
84189
84190   if (!jarg1) {
84191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84192     return 0;
84193   }
84194   std::string arg1_str(jarg1);
84195   arg1 = &arg1_str;
84196   {
84197     try {
84198       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
84199
84200       // default behaviour of NUI TextLabel
84201       result.SetProperty( Dali::Toolkit::DevelTextLabel::Property::VERTICAL_LINE_ALIGNMENT, Dali::Toolkit::DevelText::VerticalLineAlignment::MIDDLE );
84202     } catch (std::out_of_range& e) {
84203       {
84204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84205       };
84206     } catch (std::exception& e) {
84207       {
84208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84209       };
84210     } catch (Dali::DaliException e) {
84211       {
84212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84213       };
84214     } catch (...) {
84215       {
84216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84217       };
84218     }
84219   }
84220
84221   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84222
84223   //argout typemap for const std::string&
84224
84225   return jresult;
84226 }
84227
84228
84229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
84230   void * jresult ;
84231   Dali::Toolkit::TextLabel *result = 0 ;
84232
84233   {
84234     try {
84235       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
84236     } catch (std::out_of_range& e) {
84237       {
84238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84239       };
84240     } catch (std::exception& e) {
84241       {
84242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84243       };
84244     } catch (Dali::DaliException e) {
84245       {
84246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84247       };
84248     } catch (...) {
84249       {
84250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84251       };
84252     }
84253   }
84254
84255   jresult = (void *)result;
84256   return jresult;
84257 }
84258
84259
84260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
84261   void * jresult ;
84262   Dali::Toolkit::TextLabel *arg1 = 0 ;
84263   Dali::Toolkit::TextLabel *result = 0 ;
84264
84265   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84266   if (!arg1) {
84267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84268     return 0;
84269   }
84270   {
84271     try {
84272       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
84273     } catch (std::out_of_range& e) {
84274       {
84275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84276       };
84277     } catch (std::exception& e) {
84278       {
84279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84280       };
84281     } catch (Dali::DaliException e) {
84282       {
84283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84284       };
84285     } catch (...) {
84286       {
84287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84288       };
84289     }
84290   }
84291
84292   jresult = (void *)result;
84293   return jresult;
84294 }
84295
84296
84297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
84298   void * jresult ;
84299   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84300   Dali::Toolkit::TextLabel *arg2 = 0 ;
84301   Dali::Toolkit::TextLabel *result = 0 ;
84302
84303   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84304   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
84305   if (!arg2) {
84306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84307     return 0;
84308   }
84309   {
84310     try {
84311       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
84312     } catch (std::out_of_range& e) {
84313       {
84314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84315       };
84316     } catch (std::exception& e) {
84317       {
84318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84319       };
84320     } catch (Dali::DaliException e) {
84321       {
84322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84323       };
84324     } catch (...) {
84325       {
84326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84327       };
84328     }
84329   }
84330
84331   jresult = (void *)result;
84332   return jresult;
84333 }
84334
84335
84336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
84337   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84338
84339   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84340   {
84341     try {
84342       delete arg1;
84343     } catch (std::out_of_range& e) {
84344       {
84345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84346       };
84347     } catch (std::exception& e) {
84348       {
84349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84350       };
84351     } catch (Dali::DaliException e) {
84352       {
84353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84354       };
84355     } catch (...) {
84356       {
84357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84358       };
84359     }
84360   }
84361
84362 }
84363
84364
84365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
84366   void * jresult ;
84367   Dali::BaseHandle arg1 ;
84368   Dali::BaseHandle *argp1 ;
84369   Dali::Toolkit::TextLabel result;
84370
84371   argp1 = (Dali::BaseHandle *)jarg1;
84372   if (!argp1) {
84373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84374     return 0;
84375   }
84376   arg1 = *argp1;
84377   {
84378     try {
84379       result = Dali::Toolkit::TextLabel::DownCast(arg1);
84380     } catch (std::out_of_range& e) {
84381       {
84382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84383       };
84384     } catch (std::exception& e) {
84385       {
84386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84387       };
84388     } catch (Dali::DaliException e) {
84389       {
84390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84391       };
84392     } catch (...) {
84393       {
84394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84395       };
84396     }
84397   }
84398
84399   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84400   return jresult;
84401 }
84402
84403
84404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
84405   void * jresult ;
84406   Dali::Toolkit::AccessibilityManager *result = 0 ;
84407
84408   {
84409     try {
84410       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
84411     } catch (std::out_of_range& e) {
84412       {
84413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84414       };
84415     } catch (std::exception& e) {
84416       {
84417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84418       };
84419     } catch (Dali::DaliException e) {
84420       {
84421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84422       };
84423     } catch (...) {
84424       {
84425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84426       };
84427     }
84428   }
84429
84430   jresult = (void *)result;
84431   return jresult;
84432 }
84433
84434
84435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
84436   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84437
84438   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84439   {
84440     try {
84441       delete arg1;
84442     } catch (std::out_of_range& e) {
84443       {
84444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84445       };
84446     } catch (std::exception& e) {
84447       {
84448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84449       };
84450     } catch (Dali::DaliException e) {
84451       {
84452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84453       };
84454     } catch (...) {
84455       {
84456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84457       };
84458     }
84459   }
84460
84461 }
84462
84463
84464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
84465   void * jresult ;
84466   Dali::Toolkit::AccessibilityManager result;
84467
84468   {
84469     try {
84470       result = Dali::Toolkit::AccessibilityManager::Get();
84471     } catch (std::out_of_range& e) {
84472       {
84473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84474       };
84475     } catch (std::exception& e) {
84476       {
84477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84478       };
84479     } catch (Dali::DaliException e) {
84480       {
84481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84482       };
84483     } catch (...) {
84484       {
84485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84486       };
84487     }
84488   }
84489
84490   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
84491   return jresult;
84492 }
84493
84494
84495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
84496   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84497   Dali::Actor arg2 ;
84498   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84499   std::string *arg4 = 0 ;
84500   Dali::Actor *argp2 ;
84501
84502   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84503   argp2 = (Dali::Actor *)jarg2;
84504   if (!argp2) {
84505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84506     return ;
84507   }
84508   arg2 = *argp2;
84509   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84510   if (!jarg4) {
84511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84512     return ;
84513   }
84514   std::string arg4_str(jarg4);
84515   arg4 = &arg4_str;
84516   {
84517     try {
84518       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
84519     } catch (std::out_of_range& e) {
84520       {
84521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84522       };
84523     } catch (std::exception& e) {
84524       {
84525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84526       };
84527     } catch (Dali::DaliException e) {
84528       {
84529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84530       };
84531     } catch (...) {
84532       {
84533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84534       };
84535     }
84536   }
84537
84538
84539   //argout typemap for const std::string&
84540
84541 }
84542
84543
84544 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
84545   char * jresult ;
84546   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84547   Dali::Actor arg2 ;
84548   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84549   Dali::Actor *argp2 ;
84550   std::string result;
84551
84552   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84553   argp2 = (Dali::Actor *)jarg2;
84554   if (!argp2) {
84555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84556     return 0;
84557   }
84558   arg2 = *argp2;
84559   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84560   {
84561     try {
84562       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
84563     } catch (std::out_of_range& e) {
84564       {
84565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84566       };
84567     } catch (std::exception& e) {
84568       {
84569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84570       };
84571     } catch (Dali::DaliException e) {
84572       {
84573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84574       };
84575     } catch (...) {
84576       {
84577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84578       };
84579     }
84580   }
84581
84582   jresult = SWIG_csharp_string_callback((&result)->c_str());
84583   return jresult;
84584 }
84585
84586
84587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
84588   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84589   Dali::Actor arg2 ;
84590   unsigned int arg3 ;
84591   Dali::Actor *argp2 ;
84592
84593   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84594   argp2 = (Dali::Actor *)jarg2;
84595   if (!argp2) {
84596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84597     return ;
84598   }
84599   arg2 = *argp2;
84600   arg3 = (unsigned int)jarg3;
84601   {
84602     try {
84603       (arg1)->SetFocusOrder(arg2,arg3);
84604     } catch (std::out_of_range& e) {
84605       {
84606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84607       };
84608     } catch (std::exception& e) {
84609       {
84610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84611       };
84612     } catch (Dali::DaliException e) {
84613       {
84614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84615       };
84616     } catch (...) {
84617       {
84618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84619       };
84620     }
84621   }
84622
84623 }
84624
84625
84626 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
84627   unsigned int jresult ;
84628   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84629   Dali::Actor arg2 ;
84630   Dali::Actor *argp2 ;
84631   unsigned int result;
84632
84633   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84634   argp2 = (Dali::Actor *)jarg2;
84635   if (!argp2) {
84636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84637     return 0;
84638   }
84639   arg2 = *argp2;
84640   {
84641     try {
84642       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
84643     } catch (std::out_of_range& e) {
84644       {
84645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84646       };
84647     } catch (std::exception& e) {
84648       {
84649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84650       };
84651     } catch (Dali::DaliException e) {
84652       {
84653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84654       };
84655     } catch (...) {
84656       {
84657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84658       };
84659     }
84660   }
84661
84662   jresult = result;
84663   return jresult;
84664 }
84665
84666
84667 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
84668   unsigned int jresult ;
84669   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84670   unsigned int result;
84671
84672   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84673   {
84674     try {
84675       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
84676     } catch (std::out_of_range& e) {
84677       {
84678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84679       };
84680     } catch (std::exception& e) {
84681       {
84682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84683       };
84684     } catch (Dali::DaliException e) {
84685       {
84686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84687       };
84688     } catch (...) {
84689       {
84690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84691       };
84692     }
84693   }
84694
84695   jresult = result;
84696   return jresult;
84697 }
84698
84699
84700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
84701   void * jresult ;
84702   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84703   unsigned int arg2 ;
84704   Dali::Actor result;
84705
84706   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84707   arg2 = (unsigned int)jarg2;
84708   {
84709     try {
84710       result = (arg1)->GetActorByFocusOrder(arg2);
84711     } catch (std::out_of_range& e) {
84712       {
84713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84714       };
84715     } catch (std::exception& e) {
84716       {
84717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84718       };
84719     } catch (Dali::DaliException e) {
84720       {
84721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84722       };
84723     } catch (...) {
84724       {
84725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84726       };
84727     }
84728   }
84729
84730   jresult = new Dali::Actor((const Dali::Actor &)result);
84731   return jresult;
84732 }
84733
84734
84735 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
84736   unsigned int jresult ;
84737   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84738   Dali::Actor arg2 ;
84739   Dali::Actor *argp2 ;
84740   bool result;
84741
84742   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84743   argp2 = (Dali::Actor *)jarg2;
84744   if (!argp2) {
84745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84746     return 0;
84747   }
84748   arg2 = *argp2;
84749   {
84750     try {
84751       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
84752     } catch (std::out_of_range& e) {
84753       {
84754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84755       };
84756     } catch (std::exception& e) {
84757       {
84758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84759       };
84760     } catch (Dali::DaliException e) {
84761       {
84762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84763       };
84764     } catch (...) {
84765       {
84766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84767       };
84768     }
84769   }
84770
84771   jresult = result;
84772   return jresult;
84773 }
84774
84775
84776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
84777   void * jresult ;
84778   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84779   Dali::Actor result;
84780
84781   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84782   {
84783     try {
84784       result = (arg1)->GetCurrentFocusActor();
84785     } catch (std::out_of_range& e) {
84786       {
84787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84788       };
84789     } catch (std::exception& e) {
84790       {
84791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84792       };
84793     } catch (Dali::DaliException e) {
84794       {
84795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84796       };
84797     } catch (...) {
84798       {
84799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84800       };
84801     }
84802   }
84803
84804   jresult = new Dali::Actor((const Dali::Actor &)result);
84805   return jresult;
84806 }
84807
84808
84809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
84810   void * jresult ;
84811   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84812   Dali::Actor result;
84813
84814   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84815   {
84816     try {
84817       result = (arg1)->GetCurrentFocusGroup();
84818     } catch (std::out_of_range& e) {
84819       {
84820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84821       };
84822     } catch (std::exception& e) {
84823       {
84824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84825       };
84826     } catch (Dali::DaliException e) {
84827       {
84828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84829       };
84830     } catch (...) {
84831       {
84832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84833       };
84834     }
84835   }
84836
84837   jresult = new Dali::Actor((const Dali::Actor &)result);
84838   return jresult;
84839 }
84840
84841
84842 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
84843   unsigned int jresult ;
84844   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84845   unsigned int result;
84846
84847   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84848   {
84849     try {
84850       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
84851     } catch (std::out_of_range& e) {
84852       {
84853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84854       };
84855     } catch (std::exception& e) {
84856       {
84857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84858       };
84859     } catch (Dali::DaliException e) {
84860       {
84861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84862       };
84863     } catch (...) {
84864       {
84865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84866       };
84867     }
84868   }
84869
84870   jresult = result;
84871   return jresult;
84872 }
84873
84874
84875 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
84876   unsigned int jresult ;
84877   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84878   bool result;
84879
84880   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84881   {
84882     try {
84883       result = (bool)(arg1)->MoveFocusForward();
84884     } catch (std::out_of_range& e) {
84885       {
84886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84887       };
84888     } catch (std::exception& e) {
84889       {
84890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84891       };
84892     } catch (Dali::DaliException e) {
84893       {
84894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84895       };
84896     } catch (...) {
84897       {
84898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84899       };
84900     }
84901   }
84902
84903   jresult = result;
84904   return jresult;
84905 }
84906
84907
84908 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
84909   unsigned int jresult ;
84910   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84911   bool result;
84912
84913   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84914   {
84915     try {
84916       result = (bool)(arg1)->MoveFocusBackward();
84917     } catch (std::out_of_range& e) {
84918       {
84919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84920       };
84921     } catch (std::exception& e) {
84922       {
84923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84924       };
84925     } catch (Dali::DaliException e) {
84926       {
84927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84928       };
84929     } catch (...) {
84930       {
84931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84932       };
84933     }
84934   }
84935
84936   jresult = result;
84937   return jresult;
84938 }
84939
84940
84941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
84942   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84943
84944   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84945   {
84946     try {
84947       (arg1)->ClearFocus();
84948     } catch (std::out_of_range& e) {
84949       {
84950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84951       };
84952     } catch (std::exception& e) {
84953       {
84954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84955       };
84956     } catch (Dali::DaliException e) {
84957       {
84958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84959       };
84960     } catch (...) {
84961       {
84962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84963       };
84964     }
84965   }
84966
84967 }
84968
84969
84970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
84971   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84972
84973   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84974   {
84975     try {
84976       (arg1)->Reset();
84977     } catch (std::out_of_range& e) {
84978       {
84979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84980       };
84981     } catch (std::exception& e) {
84982       {
84983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84984       };
84985     } catch (Dali::DaliException e) {
84986       {
84987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84988       };
84989     } catch (...) {
84990       {
84991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84992       };
84993     }
84994   }
84995
84996 }
84997
84998
84999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
85000   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85001   Dali::Actor arg2 ;
85002   bool arg3 ;
85003   Dali::Actor *argp2 ;
85004
85005   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85006   argp2 = (Dali::Actor *)jarg2;
85007   if (!argp2) {
85008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85009     return ;
85010   }
85011   arg2 = *argp2;
85012   arg3 = jarg3 ? true : false;
85013   {
85014     try {
85015       (arg1)->SetFocusGroup(arg2,arg3);
85016     } catch (std::out_of_range& e) {
85017       {
85018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85019       };
85020     } catch (std::exception& e) {
85021       {
85022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85023       };
85024     } catch (Dali::DaliException e) {
85025       {
85026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85027       };
85028     } catch (...) {
85029       {
85030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85031       };
85032     }
85033   }
85034
85035 }
85036
85037
85038 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
85039   unsigned int jresult ;
85040   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85041   Dali::Actor arg2 ;
85042   Dali::Actor *argp2 ;
85043   bool result;
85044
85045   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85046   argp2 = (Dali::Actor *)jarg2;
85047   if (!argp2) {
85048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85049     return 0;
85050   }
85051   arg2 = *argp2;
85052   {
85053     try {
85054       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
85055     } catch (std::out_of_range& e) {
85056       {
85057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85058       };
85059     } catch (std::exception& e) {
85060       {
85061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85062       };
85063     } catch (Dali::DaliException e) {
85064       {
85065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85066       };
85067     } catch (...) {
85068       {
85069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85070       };
85071     }
85072   }
85073
85074   jresult = result;
85075   return jresult;
85076 }
85077
85078
85079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
85080   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85081   bool arg2 ;
85082
85083   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85084   arg2 = jarg2 ? true : false;
85085   {
85086     try {
85087       (arg1)->SetGroupMode(arg2);
85088     } catch (std::out_of_range& e) {
85089       {
85090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85091       };
85092     } catch (std::exception& e) {
85093       {
85094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85095       };
85096     } catch (Dali::DaliException e) {
85097       {
85098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85099       };
85100     } catch (...) {
85101       {
85102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85103       };
85104     }
85105   }
85106
85107 }
85108
85109
85110 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
85111   unsigned int jresult ;
85112   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85113   bool result;
85114
85115   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85116   {
85117     try {
85118       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
85119     } catch (std::out_of_range& e) {
85120       {
85121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85122       };
85123     } catch (std::exception& e) {
85124       {
85125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85126       };
85127     } catch (Dali::DaliException e) {
85128       {
85129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85130       };
85131     } catch (...) {
85132       {
85133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85134       };
85135     }
85136   }
85137
85138   jresult = result;
85139   return jresult;
85140 }
85141
85142
85143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
85144   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85145   bool arg2 ;
85146
85147   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85148   arg2 = jarg2 ? true : false;
85149   {
85150     try {
85151       (arg1)->SetWrapMode(arg2);
85152     } catch (std::out_of_range& e) {
85153       {
85154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85155       };
85156     } catch (std::exception& e) {
85157       {
85158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85159       };
85160     } catch (Dali::DaliException e) {
85161       {
85162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85163       };
85164     } catch (...) {
85165       {
85166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85167       };
85168     }
85169   }
85170
85171 }
85172
85173
85174 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
85175   unsigned int jresult ;
85176   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85177   bool result;
85178
85179   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85180   {
85181     try {
85182       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
85183     } catch (std::out_of_range& e) {
85184       {
85185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85186       };
85187     } catch (std::exception& e) {
85188       {
85189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85190       };
85191     } catch (Dali::DaliException e) {
85192       {
85193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85194       };
85195     } catch (...) {
85196       {
85197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85198       };
85199     }
85200   }
85201
85202   jresult = result;
85203   return jresult;
85204 }
85205
85206
85207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
85208   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85209   Dali::Actor arg2 ;
85210   Dali::Actor *argp2 ;
85211
85212   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85213   argp2 = (Dali::Actor *)jarg2;
85214   if (!argp2) {
85215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85216     return ;
85217   }
85218   arg2 = *argp2;
85219   {
85220     try {
85221       (arg1)->SetFocusIndicatorActor(arg2);
85222     } catch (std::out_of_range& e) {
85223       {
85224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85225       };
85226     } catch (std::exception& e) {
85227       {
85228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85229       };
85230     } catch (Dali::DaliException e) {
85231       {
85232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85233       };
85234     } catch (...) {
85235       {
85236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85237       };
85238     }
85239   }
85240
85241 }
85242
85243
85244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
85245   void * jresult ;
85246   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85247   Dali::Actor result;
85248
85249   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85250   {
85251     try {
85252       result = (arg1)->GetFocusIndicatorActor();
85253     } catch (std::out_of_range& e) {
85254       {
85255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85256       };
85257     } catch (std::exception& e) {
85258       {
85259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85260       };
85261     } catch (Dali::DaliException e) {
85262       {
85263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85264       };
85265     } catch (...) {
85266       {
85267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85268       };
85269     }
85270   }
85271
85272   jresult = new Dali::Actor((const Dali::Actor &)result);
85273   return jresult;
85274 }
85275
85276
85277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
85278   void * jresult ;
85279   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85280   Dali::Actor arg2 ;
85281   Dali::Actor *argp2 ;
85282   Dali::Actor result;
85283
85284   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85285   argp2 = (Dali::Actor *)jarg2;
85286   if (!argp2) {
85287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85288     return 0;
85289   }
85290   arg2 = *argp2;
85291   {
85292     try {
85293       result = (arg1)->GetFocusGroup(arg2);
85294     } catch (std::out_of_range& e) {
85295       {
85296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85297       };
85298     } catch (std::exception& e) {
85299       {
85300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85301       };
85302     } catch (Dali::DaliException e) {
85303       {
85304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85305       };
85306     } catch (...) {
85307       {
85308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85309       };
85310     }
85311   }
85312
85313   jresult = new Dali::Actor((const Dali::Actor &)result);
85314   return jresult;
85315 }
85316
85317
85318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
85319   void * jresult ;
85320   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85321   Dali::Vector2 result;
85322
85323   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85324   {
85325     try {
85326       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
85327     } catch (std::out_of_range& e) {
85328       {
85329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85330       };
85331     } catch (std::exception& e) {
85332       {
85333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85334       };
85335     } catch (Dali::DaliException e) {
85336       {
85337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85338       };
85339     } catch (...) {
85340       {
85341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85342       };
85343     }
85344   }
85345
85346   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
85347   return jresult;
85348 }
85349
85350
85351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
85352   void * jresult ;
85353   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85354   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
85355
85356   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85357   {
85358     try {
85359       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
85360     } catch (std::out_of_range& e) {
85361       {
85362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85363       };
85364     } catch (std::exception& e) {
85365       {
85366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85367       };
85368     } catch (Dali::DaliException e) {
85369       {
85370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85371       };
85372     } catch (...) {
85373       {
85374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85375       };
85376     }
85377   }
85378
85379   jresult = (void *)result;
85380   return jresult;
85381 }
85382
85383
85384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
85385   void * jresult ;
85386   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85387   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
85388
85389   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85390   {
85391     try {
85392       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
85393     } catch (std::out_of_range& e) {
85394       {
85395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85396       };
85397     } catch (std::exception& e) {
85398       {
85399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85400       };
85401     } catch (Dali::DaliException e) {
85402       {
85403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85404       };
85405     } catch (...) {
85406       {
85407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85408       };
85409     }
85410   }
85411
85412   jresult = (void *)result;
85413   return jresult;
85414 }
85415
85416
85417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
85418   void * jresult ;
85419   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85420   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
85421
85422   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85423   {
85424     try {
85425       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
85426     } catch (std::out_of_range& e) {
85427       {
85428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85429       };
85430     } catch (std::exception& e) {
85431       {
85432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85433       };
85434     } catch (Dali::DaliException e) {
85435       {
85436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85437       };
85438     } catch (...) {
85439       {
85440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85441       };
85442     }
85443   }
85444
85445   jresult = (void *)result;
85446   return jresult;
85447 }
85448
85449
85450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
85451   void * jresult ;
85452   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85453   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85454
85455   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85456   {
85457     try {
85458       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
85459     } catch (std::out_of_range& e) {
85460       {
85461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85462       };
85463     } catch (std::exception& e) {
85464       {
85465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85466       };
85467     } catch (Dali::DaliException e) {
85468       {
85469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85470       };
85471     } catch (...) {
85472       {
85473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85474       };
85475     }
85476   }
85477
85478   jresult = (void *)result;
85479   return jresult;
85480 }
85481
85482
85483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
85484   void * jresult ;
85485   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85486   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85487
85488   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85489   {
85490     try {
85491       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
85492     } catch (std::out_of_range& e) {
85493       {
85494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85495       };
85496     } catch (std::exception& e) {
85497       {
85498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85499       };
85500     } catch (Dali::DaliException e) {
85501       {
85502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85503       };
85504     } catch (...) {
85505       {
85506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85507       };
85508     }
85509   }
85510
85511   jresult = (void *)result;
85512   return jresult;
85513 }
85514
85515
85516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
85517   void * jresult ;
85518   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85519   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85520
85521   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85522   {
85523     try {
85524       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
85525     } catch (std::out_of_range& e) {
85526       {
85527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85528       };
85529     } catch (std::exception& e) {
85530       {
85531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85532       };
85533     } catch (Dali::DaliException e) {
85534       {
85535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85536       };
85537     } catch (...) {
85538       {
85539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85540       };
85541     }
85542   }
85543
85544   jresult = (void *)result;
85545   return jresult;
85546 }
85547
85548
85549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
85550   void * jresult ;
85551   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85552   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85553
85554   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85555   {
85556     try {
85557       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
85558     } catch (std::out_of_range& e) {
85559       {
85560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85561       };
85562     } catch (std::exception& e) {
85563       {
85564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85565       };
85566     } catch (Dali::DaliException e) {
85567       {
85568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85569       };
85570     } catch (...) {
85571       {
85572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85573       };
85574     }
85575   }
85576
85577   jresult = (void *)result;
85578   return jresult;
85579 }
85580
85581
85582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
85583   void * jresult ;
85584   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85585   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85586
85587   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85588   {
85589     try {
85590       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
85591     } catch (std::out_of_range& e) {
85592       {
85593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85594       };
85595     } catch (std::exception& e) {
85596       {
85597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85598       };
85599     } catch (Dali::DaliException e) {
85600       {
85601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85602       };
85603     } catch (...) {
85604       {
85605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85606       };
85607     }
85608   }
85609
85610   jresult = (void *)result;
85611   return jresult;
85612 }
85613
85614
85615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
85616   void * jresult ;
85617   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85618   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85619
85620   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85621   {
85622     try {
85623       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
85624     } catch (std::out_of_range& e) {
85625       {
85626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85627       };
85628     } catch (std::exception& e) {
85629       {
85630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85631       };
85632     } catch (Dali::DaliException e) {
85633       {
85634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85635       };
85636     } catch (...) {
85637       {
85638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85639       };
85640     }
85641   }
85642
85643   jresult = (void *)result;
85644   return jresult;
85645 }
85646
85647
85648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
85649   void * jresult ;
85650   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85651   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85652
85653   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85654   {
85655     try {
85656       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
85657     } catch (std::out_of_range& e) {
85658       {
85659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85660       };
85661     } catch (std::exception& e) {
85662       {
85663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85664       };
85665     } catch (Dali::DaliException e) {
85666       {
85667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85668       };
85669     } catch (...) {
85670       {
85671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85672       };
85673     }
85674   }
85675
85676   jresult = (void *)result;
85677   return jresult;
85678 }
85679
85680
85681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
85682   void * jresult ;
85683   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85684   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85685
85686   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85687   {
85688     try {
85689       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
85690     } catch (std::out_of_range& e) {
85691       {
85692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85693       };
85694     } catch (std::exception& e) {
85695       {
85696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85697       };
85698     } catch (Dali::DaliException e) {
85699       {
85700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85701       };
85702     } catch (...) {
85703       {
85704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85705       };
85706     }
85707   }
85708
85709   jresult = (void *)result;
85710   return jresult;
85711 }
85712
85713
85714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
85715   void * jresult ;
85716   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85717   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85718
85719   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85720   {
85721     try {
85722       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
85723     } catch (std::out_of_range& e) {
85724       {
85725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85726       };
85727     } catch (std::exception& e) {
85728       {
85729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85730       };
85731     } catch (Dali::DaliException e) {
85732       {
85733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85734       };
85735     } catch (...) {
85736       {
85737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85738       };
85739     }
85740   }
85741
85742   jresult = (void *)result;
85743   return jresult;
85744 }
85745
85746
85747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
85748   void * jresult ;
85749   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85750   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85751
85752   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85753   {
85754     try {
85755       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
85756     } catch (std::out_of_range& e) {
85757       {
85758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85759       };
85760     } catch (std::exception& e) {
85761       {
85762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85763       };
85764     } catch (Dali::DaliException e) {
85765       {
85766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85767       };
85768     } catch (...) {
85769       {
85770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85771       };
85772     }
85773   }
85774
85775   jresult = (void *)result;
85776   return jresult;
85777 }
85778
85779
85780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
85781   void * jresult ;
85782   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85783   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85784
85785   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85786   {
85787     try {
85788       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
85789     } catch (std::out_of_range& e) {
85790       {
85791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85792       };
85793     } catch (std::exception& e) {
85794       {
85795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85796       };
85797     } catch (Dali::DaliException e) {
85798       {
85799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85800       };
85801     } catch (...) {
85802       {
85803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85804       };
85805     }
85806   }
85807
85808   jresult = (void *)result;
85809   return jresult;
85810 }
85811
85812
85813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
85814   void * jresult ;
85815   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85816   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85817
85818   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85819   {
85820     try {
85821       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
85822     } catch (std::out_of_range& e) {
85823       {
85824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85825       };
85826     } catch (std::exception& e) {
85827       {
85828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85829       };
85830     } catch (Dali::DaliException e) {
85831       {
85832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85833       };
85834     } catch (...) {
85835       {
85836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85837       };
85838     }
85839   }
85840
85841   jresult = (void *)result;
85842   return jresult;
85843 }
85844
85845
85846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
85847   void * jresult ;
85848   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85849   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85850
85851   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85852   {
85853     try {
85854       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
85855     } catch (std::out_of_range& e) {
85856       {
85857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85858       };
85859     } catch (std::exception& e) {
85860       {
85861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85862       };
85863     } catch (Dali::DaliException e) {
85864       {
85865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85866       };
85867     } catch (...) {
85868       {
85869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85870       };
85871     }
85872   }
85873
85874   jresult = (void *)result;
85875   return jresult;
85876 }
85877
85878
85879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
85880   void * jresult ;
85881   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85882   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85883
85884   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85885   {
85886     try {
85887       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
85888     } catch (std::out_of_range& e) {
85889       {
85890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85891       };
85892     } catch (std::exception& e) {
85893       {
85894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85895       };
85896     } catch (Dali::DaliException e) {
85897       {
85898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85899       };
85900     } catch (...) {
85901       {
85902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85903       };
85904     }
85905   }
85906
85907   jresult = (void *)result;
85908   return jresult;
85909 }
85910
85911
85912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
85913   void * jresult ;
85914   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85915   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85916
85917   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85918   {
85919     try {
85920       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
85921     } catch (std::out_of_range& e) {
85922       {
85923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85924       };
85925     } catch (std::exception& e) {
85926       {
85927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85928       };
85929     } catch (Dali::DaliException e) {
85930       {
85931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85932       };
85933     } catch (...) {
85934       {
85935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85936       };
85937     }
85938   }
85939
85940   jresult = (void *)result;
85941   return jresult;
85942 }
85943
85944
85945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
85946   void * jresult ;
85947   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85948   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85949
85950   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85951   {
85952     try {
85953       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
85954     } catch (std::out_of_range& e) {
85955       {
85956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85957       };
85958     } catch (std::exception& e) {
85959       {
85960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85961       };
85962     } catch (Dali::DaliException e) {
85963       {
85964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85965       };
85966     } catch (...) {
85967       {
85968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85969       };
85970     }
85971   }
85972
85973   jresult = (void *)result;
85974   return jresult;
85975 }
85976
85977
85978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
85979   void * jresult ;
85980   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85981   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85982
85983   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85984   {
85985     try {
85986       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
85987     } catch (std::out_of_range& e) {
85988       {
85989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85990       };
85991     } catch (std::exception& e) {
85992       {
85993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85994       };
85995     } catch (Dali::DaliException e) {
85996       {
85997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85998       };
85999     } catch (...) {
86000       {
86001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86002       };
86003     }
86004   }
86005
86006   jresult = (void *)result;
86007   return jresult;
86008 }
86009
86010
86011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
86012   void * jresult ;
86013   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86014   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86015
86016   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86017   {
86018     try {
86019       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
86020     } catch (std::out_of_range& e) {
86021       {
86022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86023       };
86024     } catch (std::exception& e) {
86025       {
86026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86027       };
86028     } catch (Dali::DaliException e) {
86029       {
86030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86031       };
86032     } catch (...) {
86033       {
86034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86035       };
86036     }
86037   }
86038
86039   jresult = (void *)result;
86040   return jresult;
86041 }
86042
86043
86044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
86045   void * jresult ;
86046   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86047   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86048
86049   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86050   {
86051     try {
86052       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
86053     } catch (std::out_of_range& e) {
86054       {
86055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86056       };
86057     } catch (std::exception& e) {
86058       {
86059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86060       };
86061     } catch (Dali::DaliException e) {
86062       {
86063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86064       };
86065     } catch (...) {
86066       {
86067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86068       };
86069     }
86070   }
86071
86072   jresult = (void *)result;
86073   return jresult;
86074 }
86075
86076
86077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
86078   void * jresult ;
86079   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86080   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86081
86082   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86083   {
86084     try {
86085       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
86086     } catch (std::out_of_range& e) {
86087       {
86088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86089       };
86090     } catch (std::exception& e) {
86091       {
86092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86093       };
86094     } catch (Dali::DaliException e) {
86095       {
86096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86097       };
86098     } catch (...) {
86099       {
86100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86101       };
86102     }
86103   }
86104
86105   jresult = (void *)result;
86106   return jresult;
86107 }
86108
86109
86110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
86111   void * jresult ;
86112   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86113   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86114
86115   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86116   {
86117     try {
86118       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
86119     } catch (std::out_of_range& e) {
86120       {
86121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86122       };
86123     } catch (std::exception& e) {
86124       {
86125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86126       };
86127     } catch (Dali::DaliException e) {
86128       {
86129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86130       };
86131     } catch (...) {
86132       {
86133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86134       };
86135     }
86136   }
86137
86138   jresult = (void *)result;
86139   return jresult;
86140 }
86141
86142
86143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
86144   void * jresult ;
86145   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86146   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86147
86148   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86149   {
86150     try {
86151       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
86152     } catch (std::out_of_range& e) {
86153       {
86154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86155       };
86156     } catch (std::exception& e) {
86157       {
86158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86159       };
86160     } catch (Dali::DaliException e) {
86161       {
86162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86163       };
86164     } catch (...) {
86165       {
86166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86167       };
86168     }
86169   }
86170
86171   jresult = (void *)result;
86172   return jresult;
86173 }
86174
86175
86176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
86177   void * jresult ;
86178   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86179   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86180
86181   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86182   {
86183     try {
86184       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
86185     } catch (std::out_of_range& e) {
86186       {
86187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86188       };
86189     } catch (std::exception& e) {
86190       {
86191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86192       };
86193     } catch (Dali::DaliException e) {
86194       {
86195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86196       };
86197     } catch (...) {
86198       {
86199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86200       };
86201     }
86202   }
86203
86204   jresult = (void *)result;
86205   return jresult;
86206 }
86207
86208
86209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
86210   void * jresult ;
86211   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86212   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86213
86214   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86215   {
86216     try {
86217       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
86218     } catch (std::out_of_range& e) {
86219       {
86220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86221       };
86222     } catch (std::exception& e) {
86223       {
86224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86225       };
86226     } catch (Dali::DaliException e) {
86227       {
86228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86229       };
86230     } catch (...) {
86231       {
86232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86233       };
86234     }
86235   }
86236
86237   jresult = (void *)result;
86238   return jresult;
86239 }
86240
86241
86242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
86243   void * jresult ;
86244   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86245   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86246
86247   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86248   {
86249     try {
86250       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
86251     } catch (std::out_of_range& e) {
86252       {
86253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86254       };
86255     } catch (std::exception& e) {
86256       {
86257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86258       };
86259     } catch (Dali::DaliException e) {
86260       {
86261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86262       };
86263     } catch (...) {
86264       {
86265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86266       };
86267     }
86268   }
86269
86270   jresult = (void *)result;
86271   return jresult;
86272 }
86273
86274
86275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
86276   void * jresult ;
86277   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86278   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86279
86280   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86281   {
86282     try {
86283       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
86284     } catch (std::out_of_range& e) {
86285       {
86286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86287       };
86288     } catch (std::exception& e) {
86289       {
86290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86291       };
86292     } catch (Dali::DaliException e) {
86293       {
86294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86295       };
86296     } catch (...) {
86297       {
86298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86299       };
86300     }
86301   }
86302
86303   jresult = (void *)result;
86304   return jresult;
86305 }
86306
86307
86308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
86309   void * jresult ;
86310   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86311   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
86312
86313   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86314   {
86315     try {
86316       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
86317     } catch (std::out_of_range& e) {
86318       {
86319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86320       };
86321     } catch (std::exception& e) {
86322       {
86323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86324       };
86325     } catch (Dali::DaliException e) {
86326       {
86327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86328       };
86329     } catch (...) {
86330       {
86331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86332       };
86333     }
86334   }
86335
86336   jresult = (void *)result;
86337   return jresult;
86338 }
86339
86340
86341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
86342   void * jresult ;
86343   Dali::Toolkit::StyleManager *result = 0 ;
86344
86345   {
86346     try {
86347       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
86348     } catch (std::out_of_range& e) {
86349       {
86350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86351       };
86352     } catch (std::exception& e) {
86353       {
86354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86355       };
86356     } catch (Dali::DaliException e) {
86357       {
86358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86359       };
86360     } catch (...) {
86361       {
86362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86363       };
86364     }
86365   }
86366
86367   jresult = (void *)result;
86368   return jresult;
86369 }
86370
86371
86372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
86373   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86374
86375   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86376   {
86377     try {
86378       delete arg1;
86379     } catch (std::out_of_range& e) {
86380       {
86381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86382       };
86383     } catch (std::exception& e) {
86384       {
86385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86386       };
86387     } catch (Dali::DaliException e) {
86388       {
86389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86390       };
86391     } catch (...) {
86392       {
86393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86394       };
86395     }
86396   }
86397
86398 }
86399
86400
86401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
86402   void * jresult ;
86403   Dali::Toolkit::StyleManager result;
86404
86405   {
86406     try {
86407       result = Dali::Toolkit::StyleManager::Get();
86408     } catch (std::out_of_range& e) {
86409       {
86410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86411       };
86412     } catch (std::exception& e) {
86413       {
86414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86415       };
86416     } catch (Dali::DaliException e) {
86417       {
86418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86419       };
86420     } catch (...) {
86421       {
86422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86423       };
86424     }
86425   }
86426
86427   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
86428   return jresult;
86429 }
86430
86431
86432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
86433   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86434   std::string *arg2 = 0 ;
86435
86436   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86437   if (!jarg2) {
86438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86439     return ;
86440   }
86441   std::string arg2_str(jarg2);
86442   arg2 = &arg2_str;
86443   {
86444     try {
86445       (arg1)->ApplyTheme((std::string const &)*arg2);
86446     } catch (std::out_of_range& e) {
86447       {
86448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86449       };
86450     } catch (std::exception& e) {
86451       {
86452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86453       };
86454     } catch (Dali::DaliException e) {
86455       {
86456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86457       };
86458     } catch (...) {
86459       {
86460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86461       };
86462     }
86463   }
86464
86465
86466   //argout typemap for const std::string&
86467
86468 }
86469
86470
86471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
86472   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86473
86474   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86475   {
86476     try {
86477       (arg1)->ApplyDefaultTheme();
86478     } catch (std::out_of_range& e) {
86479       {
86480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86481       };
86482     } catch (std::exception& e) {
86483       {
86484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86485       };
86486     } catch (Dali::DaliException e) {
86487       {
86488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86489       };
86490     } catch (...) {
86491       {
86492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86493       };
86494     }
86495   }
86496
86497 }
86498
86499
86500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86501   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86502   std::string *arg2 = 0 ;
86503   Dali::Property::Value *arg3 = 0 ;
86504
86505   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86506   if (!jarg2) {
86507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86508     return ;
86509   }
86510   std::string arg2_str(jarg2);
86511   arg2 = &arg2_str;
86512   arg3 = (Dali::Property::Value *)jarg3;
86513   if (!arg3) {
86514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
86515     return ;
86516   }
86517   {
86518     try {
86519       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
86520     } catch (std::out_of_range& e) {
86521       {
86522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86523       };
86524     } catch (std::exception& e) {
86525       {
86526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86527       };
86528     } catch (Dali::DaliException e) {
86529       {
86530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86531       };
86532     } catch (...) {
86533       {
86534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86535       };
86536     }
86537   }
86538
86539
86540   //argout typemap for const std::string&
86541
86542 }
86543
86544
86545 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86546   unsigned int jresult ;
86547   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86548   std::string *arg2 = 0 ;
86549   Dali::Property::Value *arg3 = 0 ;
86550   bool result;
86551
86552   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86553   if (!jarg2) {
86554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86555     return 0;
86556   }
86557   std::string arg2_str(jarg2);
86558   arg2 = &arg2_str;
86559   arg3 = (Dali::Property::Value *)jarg3;
86560   if (!arg3) {
86561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
86562     return 0;
86563   }
86564   {
86565     try {
86566       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
86567     } catch (std::out_of_range& e) {
86568       {
86569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86570       };
86571     } catch (std::exception& e) {
86572       {
86573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86574       };
86575     } catch (Dali::DaliException e) {
86576       {
86577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86578       };
86579     } catch (...) {
86580       {
86581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86582       };
86583     }
86584   }
86585
86586   jresult = result;
86587
86588   //argout typemap for const std::string&
86589
86590   return jresult;
86591 }
86592
86593
86594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
86595   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86596   Dali::Toolkit::Control arg2 ;
86597   std::string *arg3 = 0 ;
86598   std::string *arg4 = 0 ;
86599   Dali::Toolkit::Control *argp2 ;
86600
86601   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86602   argp2 = (Dali::Toolkit::Control *)jarg2;
86603   if (!argp2) {
86604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
86605     return ;
86606   }
86607   arg2 = *argp2;
86608   if (!jarg3) {
86609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86610     return ;
86611   }
86612   std::string arg3_str(jarg3);
86613   arg3 = &arg3_str;
86614   if (!jarg4) {
86615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86616     return ;
86617   }
86618   std::string arg4_str(jarg4);
86619   arg4 = &arg4_str;
86620   {
86621     try {
86622       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
86623     } catch (std::out_of_range& e) {
86624       {
86625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86626       };
86627     } catch (std::exception& e) {
86628       {
86629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86630       };
86631     } catch (Dali::DaliException e) {
86632       {
86633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86634       };
86635     } catch (...) {
86636       {
86637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86638       };
86639     }
86640   }
86641
86642
86643   //argout typemap for const std::string&
86644
86645
86646   //argout typemap for const std::string&
86647
86648 }
86649
86650
86651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
86652   void * jresult ;
86653   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86654   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
86655
86656   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86657   {
86658     try {
86659       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
86660     } catch (std::out_of_range& e) {
86661       {
86662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86663       };
86664     } catch (std::exception& e) {
86665       {
86666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86667       };
86668     } catch (Dali::DaliException e) {
86669       {
86670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86671       };
86672     } catch (...) {
86673       {
86674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86675       };
86676     }
86677   }
86678
86679   jresult = (void *)result;
86680   return jresult;
86681 }
86682
86683
86684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
86685   int jresult ;
86686   int result;
86687
86688   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
86689   jresult = (int)result;
86690   return jresult;
86691 }
86692
86693
86694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
86695   int jresult ;
86696   int result;
86697
86698   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
86699   jresult = (int)result;
86700   return jresult;
86701 }
86702
86703
86704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
86705   int jresult ;
86706   int result;
86707
86708   result = (int)Dali::Toolkit::Slider::Property::VALUE;
86709   jresult = (int)result;
86710   return jresult;
86711 }
86712
86713
86714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
86715   int jresult ;
86716   int result;
86717
86718   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
86719   jresult = (int)result;
86720   return jresult;
86721 }
86722
86723
86724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
86725   int jresult ;
86726   int result;
86727
86728   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
86729   jresult = (int)result;
86730   return jresult;
86731 }
86732
86733
86734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
86735   int jresult ;
86736   int result;
86737
86738   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
86739   jresult = (int)result;
86740   return jresult;
86741 }
86742
86743
86744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
86745   int jresult ;
86746   int result;
86747
86748   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
86749   jresult = (int)result;
86750   return jresult;
86751 }
86752
86753
86754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
86755   int jresult ;
86756   int result;
86757
86758   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
86759   jresult = (int)result;
86760   return jresult;
86761 }
86762
86763
86764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
86765   int jresult ;
86766   int result;
86767
86768   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
86769   jresult = (int)result;
86770   return jresult;
86771 }
86772
86773
86774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
86775   int jresult ;
86776   int result;
86777
86778   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
86779   jresult = (int)result;
86780   return jresult;
86781 }
86782
86783
86784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
86785   int jresult ;
86786   int result;
86787
86788   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
86789   jresult = (int)result;
86790   return jresult;
86791 }
86792
86793
86794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
86795   int jresult ;
86796   int result;
86797
86798   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
86799   jresult = (int)result;
86800   return jresult;
86801 }
86802
86803
86804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
86805   int jresult ;
86806   int result;
86807
86808   result = (int)Dali::Toolkit::Slider::Property::MARKS;
86809   jresult = (int)result;
86810   return jresult;
86811 }
86812
86813
86814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
86815   int jresult ;
86816   int result;
86817
86818   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
86819   jresult = (int)result;
86820   return jresult;
86821 }
86822
86823
86824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
86825   int jresult ;
86826   int result;
86827
86828   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
86829   jresult = (int)result;
86830   return jresult;
86831 }
86832
86833
86834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
86835   void * jresult ;
86836   Dali::Toolkit::Slider::Property *result = 0 ;
86837
86838   {
86839     try {
86840       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
86841     } catch (std::out_of_range& e) {
86842       {
86843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86844       };
86845     } catch (std::exception& e) {
86846       {
86847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86848       };
86849     } catch (Dali::DaliException e) {
86850       {
86851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86852       };
86853     } catch (...) {
86854       {
86855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86856       };
86857     }
86858   }
86859
86860   jresult = (void *)result;
86861   return jresult;
86862 }
86863
86864
86865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
86866   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
86867
86868   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
86869   {
86870     try {
86871       delete arg1;
86872     } catch (std::out_of_range& e) {
86873       {
86874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86875       };
86876     } catch (std::exception& e) {
86877       {
86878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86879       };
86880     } catch (Dali::DaliException e) {
86881       {
86882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86883       };
86884     } catch (...) {
86885       {
86886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86887       };
86888     }
86889   }
86890
86891 }
86892
86893
86894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
86895   void * jresult ;
86896   Dali::Toolkit::Slider result;
86897
86898   {
86899     try {
86900       result = Dali::Toolkit::Slider::New();
86901     } catch (std::out_of_range& e) {
86902       {
86903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86904       };
86905     } catch (std::exception& e) {
86906       {
86907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86908       };
86909     } catch (Dali::DaliException e) {
86910       {
86911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86912       };
86913     } catch (...) {
86914       {
86915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86916       };
86917     }
86918   }
86919
86920   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
86921   return jresult;
86922 }
86923
86924
86925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
86926   void * jresult ;
86927   Dali::Toolkit::Slider *result = 0 ;
86928
86929   {
86930     try {
86931       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
86932     } catch (std::out_of_range& e) {
86933       {
86934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86935       };
86936     } catch (std::exception& e) {
86937       {
86938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86939       };
86940     } catch (Dali::DaliException e) {
86941       {
86942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86943       };
86944     } catch (...) {
86945       {
86946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86947       };
86948     }
86949   }
86950
86951   jresult = (void *)result;
86952   return jresult;
86953 }
86954
86955
86956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
86957   void * jresult ;
86958   Dali::Toolkit::Slider *arg1 = 0 ;
86959   Dali::Toolkit::Slider *result = 0 ;
86960
86961   arg1 = (Dali::Toolkit::Slider *)jarg1;
86962   if (!arg1) {
86963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
86964     return 0;
86965   }
86966   {
86967     try {
86968       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
86969     } catch (std::out_of_range& e) {
86970       {
86971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86972       };
86973     } catch (std::exception& e) {
86974       {
86975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86976       };
86977     } catch (Dali::DaliException e) {
86978       {
86979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86980       };
86981     } catch (...) {
86982       {
86983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86984       };
86985     }
86986   }
86987
86988   jresult = (void *)result;
86989   return jresult;
86990 }
86991
86992
86993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
86994   void * jresult ;
86995   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86996   Dali::Toolkit::Slider *arg2 = 0 ;
86997   Dali::Toolkit::Slider *result = 0 ;
86998
86999   arg1 = (Dali::Toolkit::Slider *)jarg1;
87000   arg2 = (Dali::Toolkit::Slider *)jarg2;
87001   if (!arg2) {
87002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
87003     return 0;
87004   }
87005   {
87006     try {
87007       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
87008     } catch (std::out_of_range& e) {
87009       {
87010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87011       };
87012     } catch (std::exception& e) {
87013       {
87014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87015       };
87016     } catch (Dali::DaliException e) {
87017       {
87018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87019       };
87020     } catch (...) {
87021       {
87022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87023       };
87024     }
87025   }
87026
87027   jresult = (void *)result;
87028   return jresult;
87029 }
87030
87031
87032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
87033   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87034
87035   arg1 = (Dali::Toolkit::Slider *)jarg1;
87036   {
87037     try {
87038       delete arg1;
87039     } catch (std::out_of_range& e) {
87040       {
87041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87042       };
87043     } catch (std::exception& e) {
87044       {
87045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87046       };
87047     } catch (Dali::DaliException e) {
87048       {
87049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87050       };
87051     } catch (...) {
87052       {
87053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87054       };
87055     }
87056   }
87057
87058 }
87059
87060
87061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
87062   void * jresult ;
87063   Dali::BaseHandle arg1 ;
87064   Dali::BaseHandle *argp1 ;
87065   Dali::Toolkit::Slider result;
87066
87067   argp1 = (Dali::BaseHandle *)jarg1;
87068   if (!argp1) {
87069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87070     return 0;
87071   }
87072   arg1 = *argp1;
87073   {
87074     try {
87075       result = Dali::Toolkit::Slider::DownCast(arg1);
87076     } catch (std::out_of_range& e) {
87077       {
87078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87079       };
87080     } catch (std::exception& e) {
87081       {
87082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87083       };
87084     } catch (Dali::DaliException e) {
87085       {
87086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87087       };
87088     } catch (...) {
87089       {
87090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87091       };
87092     }
87093   }
87094
87095   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
87096   return jresult;
87097 }
87098
87099
87100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
87101   void * jresult ;
87102   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87103   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
87104
87105   arg1 = (Dali::Toolkit::Slider *)jarg1;
87106   {
87107     try {
87108       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
87109     } catch (std::out_of_range& e) {
87110       {
87111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87112       };
87113     } catch (std::exception& e) {
87114       {
87115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87116       };
87117     } catch (Dali::DaliException e) {
87118       {
87119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87120       };
87121     } catch (...) {
87122       {
87123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87124       };
87125     }
87126   }
87127
87128   jresult = (void *)result;
87129   return jresult;
87130 }
87131
87132
87133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
87134   void * jresult ;
87135   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87136   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
87137
87138   arg1 = (Dali::Toolkit::Slider *)jarg1;
87139   {
87140     try {
87141       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
87142     } catch (std::out_of_range& e) {
87143       {
87144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87145       };
87146     } catch (std::exception& e) {
87147       {
87148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87149       };
87150     } catch (Dali::DaliException e) {
87151       {
87152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87153       };
87154     } catch (...) {
87155       {
87156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87157       };
87158     }
87159   }
87160
87161   jresult = (void *)result;
87162   return jresult;
87163 }
87164
87165
87166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
87167   void * jresult ;
87168   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87169   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
87170
87171   arg1 = (Dali::Toolkit::Slider *)jarg1;
87172   {
87173     try {
87174       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
87175     } catch (std::out_of_range& e) {
87176       {
87177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87178       };
87179     } catch (std::exception& e) {
87180       {
87181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87182       };
87183     } catch (Dali::DaliException e) {
87184       {
87185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87186       };
87187     } catch (...) {
87188       {
87189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87190       };
87191     }
87192   }
87193
87194   jresult = (void *)result;
87195   return jresult;
87196 }
87197
87198
87199 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
87200   int jresult ;
87201   int result;
87202
87203   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
87204   jresult = (int)result;
87205   return jresult;
87206 }
87207
87208
87209 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
87210   int jresult ;
87211   int result;
87212
87213   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
87214   jresult = (int)result;
87215   return jresult;
87216 }
87217
87218
87219 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
87220   int jresult ;
87221   int result;
87222
87223   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
87224   jresult = (int)result;
87225   return jresult;
87226 }
87227
87228
87229 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
87230   int jresult ;
87231   int result;
87232
87233   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
87234   jresult = (int)result;
87235   return jresult;
87236 }
87237
87238
87239 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
87240   int result;
87241
87242   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
87243
87244   return result;
87245 }
87246
87247
87248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
87249   void * jresult ;
87250   Dali::Toolkit::VideoView::Property *result = 0 ;
87251
87252   {
87253     try {
87254       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
87255     } catch (std::out_of_range& e) {
87256       {
87257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87258       };
87259     } catch (std::exception& e) {
87260       {
87261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87262       };
87263     } catch (Dali::DaliException e) {
87264       {
87265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87266       };
87267     } catch (...) {
87268       {
87269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87270       };
87271     }
87272   }
87273
87274   jresult = (void *)result;
87275   return jresult;
87276 }
87277
87278
87279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
87280   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
87281
87282   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
87283   {
87284     try {
87285       delete arg1;
87286     } catch (std::out_of_range& e) {
87287       {
87288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87289       };
87290     } catch (std::exception& e) {
87291       {
87292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87293       };
87294     } catch (Dali::DaliException e) {
87295       {
87296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87297       };
87298     } catch (...) {
87299       {
87300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87301       };
87302     }
87303   }
87304
87305 }
87306
87307
87308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
87309   void * jresult ;
87310   Dali::Toolkit::VideoView result;
87311
87312   {
87313     try {
87314       result = Dali::Toolkit::VideoView::New();
87315     } catch (std::out_of_range& e) {
87316       {
87317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87318       };
87319     } catch (std::exception& e) {
87320       {
87321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87322       };
87323     } catch (Dali::DaliException e) {
87324       {
87325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87326       };
87327     } catch (...) {
87328       {
87329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87330       };
87331     }
87332   }
87333
87334   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87335   return jresult;
87336 }
87337
87338
87339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
87340   void * jresult ;
87341   std::string *arg1 = 0 ;
87342   Dali::Toolkit::VideoView result;
87343
87344   if (!jarg1) {
87345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87346     return 0;
87347   }
87348   std::string arg1_str(jarg1);
87349   arg1 = &arg1_str;
87350   {
87351     try {
87352       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
87353     } catch (std::out_of_range& e) {
87354       {
87355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87356       };
87357     } catch (std::exception& e) {
87358       {
87359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87360       };
87361     } catch (Dali::DaliException e) {
87362       {
87363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87364       };
87365     } catch (...) {
87366       {
87367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87368       };
87369     }
87370   }
87371
87372   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87373
87374   //argout typemap for const std::string&
87375
87376   return jresult;
87377 }
87378
87379
87380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
87381   void * jresult ;
87382   Dali::Toolkit::VideoView *result = 0 ;
87383
87384   {
87385     try {
87386       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
87387     } catch (std::out_of_range& e) {
87388       {
87389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87390       };
87391     } catch (std::exception& e) {
87392       {
87393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87394       };
87395     } catch (Dali::DaliException e) {
87396       {
87397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87398       };
87399     } catch (...) {
87400       {
87401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87402       };
87403     }
87404   }
87405
87406   jresult = (void *)result;
87407   return jresult;
87408 }
87409
87410
87411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
87412   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87413
87414   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87415   {
87416     try {
87417       delete arg1;
87418     } catch (std::out_of_range& e) {
87419       {
87420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87421       };
87422     } catch (std::exception& e) {
87423       {
87424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87425       };
87426     } catch (Dali::DaliException e) {
87427       {
87428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87429       };
87430     } catch (...) {
87431       {
87432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87433       };
87434     }
87435   }
87436
87437 }
87438
87439
87440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
87441   void * jresult ;
87442   Dali::Toolkit::VideoView *arg1 = 0 ;
87443   Dali::Toolkit::VideoView *result = 0 ;
87444
87445   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87446   if (!arg1) {
87447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87448     return 0;
87449   }
87450   {
87451     try {
87452       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
87453     } catch (std::out_of_range& e) {
87454       {
87455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87456       };
87457     } catch (std::exception& e) {
87458       {
87459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87460       };
87461     } catch (Dali::DaliException e) {
87462       {
87463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87464       };
87465     } catch (...) {
87466       {
87467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87468       };
87469     }
87470   }
87471
87472   jresult = (void *)result;
87473   return jresult;
87474 }
87475
87476
87477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
87478   void * jresult ;
87479   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87480   Dali::Toolkit::VideoView *arg2 = 0 ;
87481   Dali::Toolkit::VideoView *result = 0 ;
87482
87483   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87484   arg2 = (Dali::Toolkit::VideoView *)jarg2;
87485   if (!arg2) {
87486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87487     return 0;
87488   }
87489   {
87490     try {
87491       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
87492     } catch (std::out_of_range& e) {
87493       {
87494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87495       };
87496     } catch (std::exception& e) {
87497       {
87498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87499       };
87500     } catch (Dali::DaliException e) {
87501       {
87502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87503       };
87504     } catch (...) {
87505       {
87506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87507       };
87508     }
87509   }
87510
87511   jresult = (void *)result;
87512   return jresult;
87513 }
87514
87515
87516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
87517   void * jresult ;
87518   Dali::BaseHandle arg1 ;
87519   Dali::BaseHandle *argp1 ;
87520   Dali::Toolkit::VideoView result;
87521
87522   argp1 = (Dali::BaseHandle *)jarg1;
87523   if (!argp1) {
87524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87525     return 0;
87526   }
87527   arg1 = *argp1;
87528   {
87529     try {
87530       result = Dali::Toolkit::VideoView::DownCast(arg1);
87531     } catch (std::out_of_range& e) {
87532       {
87533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87534       };
87535     } catch (std::exception& e) {
87536       {
87537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87538       };
87539     } catch (Dali::DaliException e) {
87540       {
87541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87542       };
87543     } catch (...) {
87544       {
87545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87546       };
87547     }
87548   }
87549
87550   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87551   return jresult;
87552 }
87553
87554
87555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
87556   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87557
87558   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87559   {
87560     try {
87561       (arg1)->Play();
87562     } catch (std::out_of_range& e) {
87563       {
87564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87565       };
87566     } catch (std::exception& e) {
87567       {
87568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87569       };
87570     } catch (Dali::DaliException e) {
87571       {
87572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87573       };
87574     } catch (...) {
87575       {
87576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87577       };
87578     }
87579   }
87580
87581 }
87582
87583
87584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
87585   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87586
87587   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87588   {
87589     try {
87590       (arg1)->Pause();
87591     } catch (std::out_of_range& e) {
87592       {
87593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87594       };
87595     } catch (std::exception& e) {
87596       {
87597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87598       };
87599     } catch (Dali::DaliException e) {
87600       {
87601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87602       };
87603     } catch (...) {
87604       {
87605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87606       };
87607     }
87608   }
87609
87610 }
87611
87612
87613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
87614   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87615
87616   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87617   {
87618     try {
87619       (arg1)->Stop();
87620     } catch (std::out_of_range& e) {
87621       {
87622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87623       };
87624     } catch (std::exception& e) {
87625       {
87626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87627       };
87628     } catch (Dali::DaliException e) {
87629       {
87630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87631       };
87632     } catch (...) {
87633       {
87634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87635       };
87636     }
87637   }
87638
87639 }
87640
87641
87642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
87643   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87644   int arg2 ;
87645
87646   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87647   arg2 = (int)jarg2;
87648   {
87649     try {
87650       (arg1)->Forward(arg2);
87651     } catch (std::out_of_range& e) {
87652       {
87653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87654       };
87655     } catch (std::exception& e) {
87656       {
87657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87658       };
87659     } catch (Dali::DaliException e) {
87660       {
87661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87662       };
87663     } catch (...) {
87664       {
87665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87666       };
87667     }
87668   }
87669
87670 }
87671
87672
87673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
87674   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87675   int arg2 ;
87676
87677   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87678   arg2 = (int)jarg2;
87679   {
87680     try {
87681       (arg1)->Backward(arg2);
87682     } catch (std::out_of_range& e) {
87683       {
87684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87685       };
87686     } catch (std::exception& e) {
87687       {
87688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87689       };
87690     } catch (Dali::DaliException e) {
87691       {
87692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87693       };
87694     } catch (...) {
87695       {
87696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87697       };
87698     }
87699   }
87700
87701 }
87702
87703
87704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
87705   void * jresult ;
87706   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87707   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
87708
87709   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87710   {
87711     try {
87712       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
87713     } catch (std::out_of_range& e) {
87714       {
87715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87716       };
87717     } catch (std::exception& e) {
87718       {
87719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87720       };
87721     } catch (Dali::DaliException e) {
87722       {
87723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87724       };
87725     } catch (...) {
87726       {
87727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87728       };
87729     }
87730   }
87731
87732   jresult = (void *)result;
87733   return jresult;
87734 }
87735
87736
87737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
87738   int jresult ;
87739   int result;
87740
87741   result = (int)Dali::Toolkit::Popup::Property::TITLE;
87742   jresult = (int)result;
87743   return jresult;
87744 }
87745
87746
87747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
87748   int jresult ;
87749   int result;
87750
87751   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
87752   jresult = (int)result;
87753   return jresult;
87754 }
87755
87756
87757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
87758   int jresult ;
87759   int result;
87760
87761   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
87762   jresult = (int)result;
87763   return jresult;
87764 }
87765
87766
87767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
87768   int jresult ;
87769   int result;
87770
87771   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
87772   jresult = (int)result;
87773   return jresult;
87774 }
87775
87776
87777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
87778   int jresult ;
87779   int result;
87780
87781   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
87782   jresult = (int)result;
87783   return jresult;
87784 }
87785
87786
87787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
87788   int jresult ;
87789   int result;
87790
87791   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
87792   jresult = (int)result;
87793   return jresult;
87794 }
87795
87796
87797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
87798   int jresult ;
87799   int result;
87800
87801   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
87802   jresult = (int)result;
87803   return jresult;
87804 }
87805
87806
87807 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
87808   int jresult ;
87809   int result;
87810
87811   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
87812   jresult = (int)result;
87813   return jresult;
87814 }
87815
87816
87817 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
87818   int jresult ;
87819   int result;
87820
87821   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
87822   jresult = (int)result;
87823   return jresult;
87824 }
87825
87826
87827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
87828   int jresult ;
87829   int result;
87830
87831   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
87832   jresult = (int)result;
87833   return jresult;
87834 }
87835
87836
87837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
87838   int jresult ;
87839   int result;
87840
87841   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
87842   jresult = (int)result;
87843   return jresult;
87844 }
87845
87846
87847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
87848   int jresult ;
87849   int result;
87850
87851   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
87852   jresult = (int)result;
87853   return jresult;
87854 }
87855
87856
87857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
87858   int jresult ;
87859   int result;
87860
87861   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
87862   jresult = (int)result;
87863   return jresult;
87864 }
87865
87866
87867 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
87868   int jresult ;
87869   int result;
87870
87871   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
87872   jresult = (int)result;
87873   return jresult;
87874 }
87875
87876
87877 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
87878   int jresult ;
87879   int result;
87880
87881   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
87882   jresult = (int)result;
87883   return jresult;
87884 }
87885
87886
87887 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
87888   int jresult ;
87889   int result;
87890
87891   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
87892   jresult = (int)result;
87893   return jresult;
87894 }
87895
87896
87897 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
87898   int jresult ;
87899   int result;
87900
87901   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
87902   jresult = (int)result;
87903   return jresult;
87904 }
87905
87906
87907 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
87908   int jresult ;
87909   int result;
87910
87911   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
87912   jresult = (int)result;
87913   return jresult;
87914 }
87915
87916
87917 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
87918   int jresult ;
87919   int result;
87920
87921   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
87922   jresult = (int)result;
87923   return jresult;
87924 }
87925
87926
87927 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
87928   int jresult ;
87929   int result;
87930
87931   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
87932   jresult = (int)result;
87933   return jresult;
87934 }
87935
87936
87937 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
87938   int jresult ;
87939   int result;
87940
87941   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
87942   jresult = (int)result;
87943   return jresult;
87944 }
87945
87946
87947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
87948   void * jresult ;
87949   Dali::Toolkit::Popup::Property *result = 0 ;
87950
87951   {
87952     try {
87953       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
87954     } catch (std::out_of_range& e) {
87955       {
87956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87957       };
87958     } catch (std::exception& e) {
87959       {
87960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87961       };
87962     } catch (Dali::DaliException e) {
87963       {
87964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87965       };
87966     } catch (...) {
87967       {
87968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87969       };
87970     }
87971   }
87972
87973   jresult = (void *)result;
87974   return jresult;
87975 }
87976
87977
87978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
87979   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
87980
87981   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
87982   {
87983     try {
87984       delete arg1;
87985     } catch (std::out_of_range& e) {
87986       {
87987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87988       };
87989     } catch (std::exception& e) {
87990       {
87991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87992       };
87993     } catch (Dali::DaliException e) {
87994       {
87995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87996       };
87997     } catch (...) {
87998       {
87999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88000       };
88001     }
88002   }
88003
88004 }
88005
88006
88007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
88008   void * jresult ;
88009   Dali::Toolkit::Popup *result = 0 ;
88010
88011   {
88012     try {
88013       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
88014     } catch (std::out_of_range& e) {
88015       {
88016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88017       };
88018     } catch (std::exception& e) {
88019       {
88020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88021       };
88022     } catch (Dali::DaliException e) {
88023       {
88024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88025       };
88026     } catch (...) {
88027       {
88028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88029       };
88030     }
88031   }
88032
88033   jresult = (void *)result;
88034   return jresult;
88035 }
88036
88037
88038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
88039   void * jresult ;
88040   Dali::Toolkit::Popup result;
88041
88042   {
88043     try {
88044       result = Dali::Toolkit::Popup::New();
88045     } catch (std::out_of_range& e) {
88046       {
88047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88048       };
88049     } catch (std::exception& e) {
88050       {
88051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88052       };
88053     } catch (Dali::DaliException e) {
88054       {
88055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88056       };
88057     } catch (...) {
88058       {
88059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88060       };
88061     }
88062   }
88063
88064   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
88065   return jresult;
88066 }
88067
88068
88069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
88070   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88071
88072   arg1 = (Dali::Toolkit::Popup *)jarg1;
88073   {
88074     try {
88075       delete arg1;
88076     } catch (std::out_of_range& e) {
88077       {
88078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88079       };
88080     } catch (std::exception& e) {
88081       {
88082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88083       };
88084     } catch (Dali::DaliException e) {
88085       {
88086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88087       };
88088     } catch (...) {
88089       {
88090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88091       };
88092     }
88093   }
88094
88095 }
88096
88097
88098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
88099   void * jresult ;
88100   Dali::Toolkit::Popup *arg1 = 0 ;
88101   Dali::Toolkit::Popup *result = 0 ;
88102
88103   arg1 = (Dali::Toolkit::Popup *)jarg1;
88104   if (!arg1) {
88105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
88106     return 0;
88107   }
88108   {
88109     try {
88110       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
88111     } catch (std::out_of_range& e) {
88112       {
88113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88114       };
88115     } catch (std::exception& e) {
88116       {
88117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88118       };
88119     } catch (Dali::DaliException e) {
88120       {
88121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88122       };
88123     } catch (...) {
88124       {
88125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88126       };
88127     }
88128   }
88129
88130   jresult = (void *)result;
88131   return jresult;
88132 }
88133
88134
88135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
88136   void * jresult ;
88137   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88138   Dali::Toolkit::Popup *arg2 = 0 ;
88139   Dali::Toolkit::Popup *result = 0 ;
88140
88141   arg1 = (Dali::Toolkit::Popup *)jarg1;
88142   arg2 = (Dali::Toolkit::Popup *)jarg2;
88143   if (!arg2) {
88144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
88145     return 0;
88146   }
88147   {
88148     try {
88149       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
88150     } catch (std::out_of_range& e) {
88151       {
88152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88153       };
88154     } catch (std::exception& e) {
88155       {
88156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88157       };
88158     } catch (Dali::DaliException e) {
88159       {
88160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88161       };
88162     } catch (...) {
88163       {
88164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88165       };
88166     }
88167   }
88168
88169   jresult = (void *)result;
88170   return jresult;
88171 }
88172
88173
88174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
88175   void * jresult ;
88176   Dali::BaseHandle arg1 ;
88177   Dali::BaseHandle *argp1 ;
88178   Dali::Toolkit::Popup result;
88179
88180   argp1 = (Dali::BaseHandle *)jarg1;
88181   if (!argp1) {
88182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88183     return 0;
88184   }
88185   arg1 = *argp1;
88186   {
88187     try {
88188       result = Dali::Toolkit::Popup::DownCast(arg1);
88189     } catch (std::out_of_range& e) {
88190       {
88191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88192       };
88193     } catch (std::exception& e) {
88194       {
88195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88196       };
88197     } catch (Dali::DaliException e) {
88198       {
88199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88200       };
88201     } catch (...) {
88202       {
88203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88204       };
88205     }
88206   }
88207
88208   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
88209   return jresult;
88210 }
88211
88212
88213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
88214   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88215   Dali::Actor arg2 ;
88216   Dali::Actor *argp2 ;
88217
88218   arg1 = (Dali::Toolkit::Popup *)jarg1;
88219   argp2 = (Dali::Actor *)jarg2;
88220   if (!argp2) {
88221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88222     return ;
88223   }
88224   arg2 = *argp2;
88225   {
88226     try {
88227       (arg1)->SetTitle(arg2);
88228     } catch (std::out_of_range& e) {
88229       {
88230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88231       };
88232     } catch (std::exception& e) {
88233       {
88234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88235       };
88236     } catch (Dali::DaliException e) {
88237       {
88238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88239       };
88240     } catch (...) {
88241       {
88242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88243       };
88244     }
88245   }
88246
88247 }
88248
88249
88250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
88251   void * jresult ;
88252   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88253   Dali::Actor result;
88254
88255   arg1 = (Dali::Toolkit::Popup *)jarg1;
88256   {
88257     try {
88258       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
88259     } catch (std::out_of_range& e) {
88260       {
88261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88262       };
88263     } catch (std::exception& e) {
88264       {
88265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88266       };
88267     } catch (Dali::DaliException e) {
88268       {
88269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88270       };
88271     } catch (...) {
88272       {
88273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88274       };
88275     }
88276   }
88277
88278   jresult = new Dali::Actor((const Dali::Actor &)result);
88279   return jresult;
88280 }
88281
88282
88283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
88284   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88285   Dali::Actor arg2 ;
88286   Dali::Actor *argp2 ;
88287
88288   arg1 = (Dali::Toolkit::Popup *)jarg1;
88289   argp2 = (Dali::Actor *)jarg2;
88290   if (!argp2) {
88291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88292     return ;
88293   }
88294   arg2 = *argp2;
88295   {
88296     try {
88297       (arg1)->SetContent(arg2);
88298     } catch (std::out_of_range& e) {
88299       {
88300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88301       };
88302     } catch (std::exception& e) {
88303       {
88304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88305       };
88306     } catch (Dali::DaliException e) {
88307       {
88308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88309       };
88310     } catch (...) {
88311       {
88312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88313       };
88314     }
88315   }
88316
88317 }
88318
88319
88320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
88321   void * jresult ;
88322   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88323   Dali::Actor result;
88324
88325   arg1 = (Dali::Toolkit::Popup *)jarg1;
88326   {
88327     try {
88328       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
88329     } catch (std::out_of_range& e) {
88330       {
88331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88332       };
88333     } catch (std::exception& e) {
88334       {
88335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88336       };
88337     } catch (Dali::DaliException e) {
88338       {
88339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88340       };
88341     } catch (...) {
88342       {
88343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88344       };
88345     }
88346   }
88347
88348   jresult = new Dali::Actor((const Dali::Actor &)result);
88349   return jresult;
88350 }
88351
88352
88353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
88354   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88355   Dali::Actor arg2 ;
88356   Dali::Actor *argp2 ;
88357
88358   arg1 = (Dali::Toolkit::Popup *)jarg1;
88359   argp2 = (Dali::Actor *)jarg2;
88360   if (!argp2) {
88361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88362     return ;
88363   }
88364   arg2 = *argp2;
88365   {
88366     try {
88367       (arg1)->SetFooter(arg2);
88368     } catch (std::out_of_range& e) {
88369       {
88370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88371       };
88372     } catch (std::exception& e) {
88373       {
88374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88375       };
88376     } catch (Dali::DaliException e) {
88377       {
88378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88379       };
88380     } catch (...) {
88381       {
88382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88383       };
88384     }
88385   }
88386
88387 }
88388
88389
88390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
88391   void * jresult ;
88392   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88393   Dali::Actor result;
88394
88395   arg1 = (Dali::Toolkit::Popup *)jarg1;
88396   {
88397     try {
88398       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
88399     } catch (std::out_of_range& e) {
88400       {
88401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88402       };
88403     } catch (std::exception& e) {
88404       {
88405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88406       };
88407     } catch (Dali::DaliException e) {
88408       {
88409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88410       };
88411     } catch (...) {
88412       {
88413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88414       };
88415     }
88416   }
88417
88418   jresult = new Dali::Actor((const Dali::Actor &)result);
88419   return jresult;
88420 }
88421
88422
88423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
88424   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88425   Dali::Toolkit::Popup::DisplayState arg2 ;
88426
88427   arg1 = (Dali::Toolkit::Popup *)jarg1;
88428   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
88429   {
88430     try {
88431       (arg1)->SetDisplayState(arg2);
88432     } catch (std::out_of_range& e) {
88433       {
88434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88435       };
88436     } catch (std::exception& e) {
88437       {
88438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88439       };
88440     } catch (Dali::DaliException e) {
88441       {
88442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88443       };
88444     } catch (...) {
88445       {
88446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88447       };
88448     }
88449   }
88450
88451 }
88452
88453
88454 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
88455   int jresult ;
88456   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88457   Dali::Toolkit::Popup::DisplayState result;
88458
88459   arg1 = (Dali::Toolkit::Popup *)jarg1;
88460   {
88461     try {
88462       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
88463     } catch (std::out_of_range& e) {
88464       {
88465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88466       };
88467     } catch (std::exception& e) {
88468       {
88469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88470       };
88471     } catch (Dali::DaliException e) {
88472       {
88473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88474       };
88475     } catch (...) {
88476       {
88477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88478       };
88479     }
88480   }
88481
88482   jresult = (int)result;
88483   return jresult;
88484 }
88485
88486
88487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
88488   void * jresult ;
88489   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88490   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
88491
88492   arg1 = (Dali::Toolkit::Popup *)jarg1;
88493   {
88494     try {
88495       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
88496     } catch (std::out_of_range& e) {
88497       {
88498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88499       };
88500     } catch (std::exception& e) {
88501       {
88502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88503       };
88504     } catch (Dali::DaliException e) {
88505       {
88506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88507       };
88508     } catch (...) {
88509       {
88510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88511       };
88512     }
88513   }
88514
88515   jresult = (void *)result;
88516   return jresult;
88517 }
88518
88519
88520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
88521   void * jresult ;
88522   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88523   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88524
88525   arg1 = (Dali::Toolkit::Popup *)jarg1;
88526   {
88527     try {
88528       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
88529     } catch (std::out_of_range& e) {
88530       {
88531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88532       };
88533     } catch (std::exception& e) {
88534       {
88535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88536       };
88537     } catch (Dali::DaliException e) {
88538       {
88539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88540       };
88541     } catch (...) {
88542       {
88543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88544       };
88545     }
88546   }
88547
88548   jresult = (void *)result;
88549   return jresult;
88550 }
88551
88552
88553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
88554   void * jresult ;
88555   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88556   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88557
88558   arg1 = (Dali::Toolkit::Popup *)jarg1;
88559   {
88560     try {
88561       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
88562     } catch (std::out_of_range& e) {
88563       {
88564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88565       };
88566     } catch (std::exception& e) {
88567       {
88568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88569       };
88570     } catch (Dali::DaliException e) {
88571       {
88572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88573       };
88574     } catch (...) {
88575       {
88576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88577       };
88578     }
88579   }
88580
88581   jresult = (void *)result;
88582   return jresult;
88583 }
88584
88585
88586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
88587   void * jresult ;
88588   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88589   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88590
88591   arg1 = (Dali::Toolkit::Popup *)jarg1;
88592   {
88593     try {
88594       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
88595     } catch (std::out_of_range& e) {
88596       {
88597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88598       };
88599     } catch (std::exception& e) {
88600       {
88601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88602       };
88603     } catch (Dali::DaliException e) {
88604       {
88605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88606       };
88607     } catch (...) {
88608       {
88609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88610       };
88611     }
88612   }
88613
88614   jresult = (void *)result;
88615   return jresult;
88616 }
88617
88618
88619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
88620   void * jresult ;
88621   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88622   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88623
88624   arg1 = (Dali::Toolkit::Popup *)jarg1;
88625   {
88626     try {
88627       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
88628     } catch (std::out_of_range& e) {
88629       {
88630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88631       };
88632     } catch (std::exception& e) {
88633       {
88634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88635       };
88636     } catch (Dali::DaliException e) {
88637       {
88638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88639       };
88640     } catch (...) {
88641       {
88642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88643       };
88644     }
88645   }
88646
88647   jresult = (void *)result;
88648   return jresult;
88649 }
88650
88651
88652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
88653   int jresult ;
88654   int result;
88655
88656   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
88657   jresult = (int)result;
88658   return jresult;
88659 }
88660
88661
88662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
88663   int jresult ;
88664   int result;
88665
88666   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
88667   jresult = (int)result;
88668   return jresult;
88669 }
88670
88671
88672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
88673   int jresult ;
88674   int result;
88675
88676   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
88677   jresult = (int)result;
88678   return jresult;
88679 }
88680
88681
88682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
88683   int jresult ;
88684   int result;
88685
88686   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
88687   jresult = (int)result;
88688   return jresult;
88689 }
88690
88691
88692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
88693   int jresult ;
88694   int result;
88695
88696   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
88697   jresult = (int)result;
88698   return jresult;
88699 }
88700
88701
88702 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
88703   int jresult ;
88704   int result;
88705
88706   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
88707   jresult = (int)result;
88708   return jresult;
88709 }
88710
88711
88712 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
88713   int jresult ;
88714   int result;
88715
88716   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
88717   jresult = (int)result;
88718   return jresult;
88719 }
88720
88721
88722 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
88723   int jresult ;
88724   int result;
88725
88726   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
88727   jresult = (int)result;
88728   return jresult;
88729 }
88730
88731
88732 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
88733   int jresult ;
88734   int result;
88735
88736   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
88737   jresult = (int)result;
88738   return jresult;
88739 }
88740
88741
88742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
88743   void * jresult ;
88744   Dali::Toolkit::ProgressBar::Property *result = 0 ;
88745
88746   {
88747     try {
88748       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
88749     } catch (std::out_of_range& e) {
88750       {
88751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88752       };
88753     } catch (std::exception& e) {
88754       {
88755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88756       };
88757     } catch (Dali::DaliException e) {
88758       {
88759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88760       };
88761     } catch (...) {
88762       {
88763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88764       };
88765     }
88766   }
88767
88768   jresult = (void *)result;
88769   return jresult;
88770 }
88771
88772
88773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
88774   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
88775
88776   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
88777   {
88778     try {
88779       delete arg1;
88780     } catch (std::out_of_range& e) {
88781       {
88782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88783       };
88784     } catch (std::exception& e) {
88785       {
88786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88787       };
88788     } catch (Dali::DaliException e) {
88789       {
88790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88791       };
88792     } catch (...) {
88793       {
88794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88795       };
88796     }
88797   }
88798
88799 }
88800
88801
88802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
88803   void * jresult ;
88804   Dali::Toolkit::ProgressBar result;
88805
88806   {
88807     try {
88808       result = Dali::Toolkit::ProgressBar::New();
88809     } catch (std::out_of_range& e) {
88810       {
88811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88812       };
88813     } catch (std::exception& e) {
88814       {
88815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88816       };
88817     } catch (Dali::DaliException e) {
88818       {
88819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88820       };
88821     } catch (...) {
88822       {
88823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88824       };
88825     }
88826   }
88827
88828   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
88829   return jresult;
88830 }
88831
88832
88833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
88834   void * jresult ;
88835   Dali::Toolkit::ProgressBar *result = 0 ;
88836
88837   {
88838     try {
88839       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
88840     } catch (std::out_of_range& e) {
88841       {
88842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88843       };
88844     } catch (std::exception& e) {
88845       {
88846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88847       };
88848     } catch (Dali::DaliException e) {
88849       {
88850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88851       };
88852     } catch (...) {
88853       {
88854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88855       };
88856     }
88857   }
88858
88859   jresult = (void *)result;
88860   return jresult;
88861 }
88862
88863
88864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
88865   void * jresult ;
88866   Dali::Toolkit::ProgressBar *arg1 = 0 ;
88867   Dali::Toolkit::ProgressBar *result = 0 ;
88868
88869   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88870   if (!arg1) {
88871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
88872     return 0;
88873   }
88874   {
88875     try {
88876       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
88877     } catch (std::out_of_range& e) {
88878       {
88879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88880       };
88881     } catch (std::exception& e) {
88882       {
88883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88884       };
88885     } catch (Dali::DaliException e) {
88886       {
88887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88888       };
88889     } catch (...) {
88890       {
88891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88892       };
88893     }
88894   }
88895
88896   jresult = (void *)result;
88897   return jresult;
88898 }
88899
88900
88901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
88902   void * jresult ;
88903   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
88904   Dali::Toolkit::ProgressBar *arg2 = 0 ;
88905   Dali::Toolkit::ProgressBar *result = 0 ;
88906
88907   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88908   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
88909   if (!arg2) {
88910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
88911     return 0;
88912   }
88913   {
88914     try {
88915       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
88916     } catch (std::out_of_range& e) {
88917       {
88918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88919       };
88920     } catch (std::exception& e) {
88921       {
88922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88923       };
88924     } catch (Dali::DaliException e) {
88925       {
88926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88927       };
88928     } catch (...) {
88929       {
88930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88931       };
88932     }
88933   }
88934
88935   jresult = (void *)result;
88936   return jresult;
88937 }
88938
88939
88940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
88941   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
88942
88943   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88944   {
88945     try {
88946       delete arg1;
88947     } catch (std::out_of_range& e) {
88948       {
88949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88950       };
88951     } catch (std::exception& e) {
88952       {
88953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88954       };
88955     } catch (Dali::DaliException e) {
88956       {
88957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88958       };
88959     } catch (...) {
88960       {
88961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88962       };
88963     }
88964   }
88965
88966 }
88967
88968
88969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
88970   void * jresult ;
88971   Dali::BaseHandle arg1 ;
88972   Dali::BaseHandle *argp1 ;
88973   Dali::Toolkit::ProgressBar result;
88974
88975   argp1 = (Dali::BaseHandle *)jarg1;
88976   if (!argp1) {
88977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88978     return 0;
88979   }
88980   arg1 = *argp1;
88981   {
88982     try {
88983       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
88984     } catch (std::out_of_range& e) {
88985       {
88986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88987       };
88988     } catch (std::exception& e) {
88989       {
88990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88991       };
88992     } catch (Dali::DaliException e) {
88993       {
88994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88995       };
88996     } catch (...) {
88997       {
88998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88999       };
89000     }
89001   }
89002
89003   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
89004   return jresult;
89005 }
89006
89007
89008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
89009   void * jresult ;
89010   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89011   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
89012
89013   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89014   {
89015     try {
89016       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
89017     } catch (std::out_of_range& e) {
89018       {
89019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89020       };
89021     } catch (std::exception& e) {
89022       {
89023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89024       };
89025     } catch (Dali::DaliException e) {
89026       {
89027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89028       };
89029     } catch (...) {
89030       {
89031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89032       };
89033     }
89034   }
89035
89036   jresult = (void *)result;
89037   return jresult;
89038 }
89039
89040
89041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
89042   void * jresult ;
89043   Dali::Toolkit::GaussianBlurView *result = 0 ;
89044
89045   {
89046     try {
89047       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
89048     } catch (std::out_of_range& e) {
89049       {
89050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89051       };
89052     } catch (std::exception& e) {
89053       {
89054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89055       };
89056     } catch (Dali::DaliException e) {
89057       {
89058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89059       };
89060     } catch (...) {
89061       {
89062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89063       };
89064     }
89065   }
89066
89067   jresult = (void *)result;
89068   return jresult;
89069 }
89070
89071
89072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
89073   void * jresult ;
89074   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
89075   Dali::Toolkit::GaussianBlurView *result = 0 ;
89076
89077   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89078   if (!arg1) {
89079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
89080     return 0;
89081   }
89082   {
89083     try {
89084       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
89085     } catch (std::out_of_range& e) {
89086       {
89087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89088       };
89089     } catch (std::exception& e) {
89090       {
89091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89092       };
89093     } catch (Dali::DaliException e) {
89094       {
89095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89096       };
89097     } catch (...) {
89098       {
89099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89100       };
89101     }
89102   }
89103
89104   jresult = (void *)result;
89105   return jresult;
89106 }
89107
89108
89109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
89110   void * jresult ;
89111   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89112   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
89113   Dali::Toolkit::GaussianBlurView *result = 0 ;
89114
89115   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89116   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
89117   if (!arg2) {
89118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
89119     return 0;
89120   }
89121   {
89122     try {
89123       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
89124     } catch (std::out_of_range& e) {
89125       {
89126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89127       };
89128     } catch (std::exception& e) {
89129       {
89130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89131       };
89132     } catch (Dali::DaliException e) {
89133       {
89134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89135       };
89136     } catch (...) {
89137       {
89138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89139       };
89140     }
89141   }
89142
89143   jresult = (void *)result;
89144   return jresult;
89145 }
89146
89147
89148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
89149   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89150
89151   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89152   {
89153     try {
89154       delete arg1;
89155     } catch (std::out_of_range& e) {
89156       {
89157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89158       };
89159     } catch (std::exception& e) {
89160       {
89161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89162       };
89163     } catch (Dali::DaliException e) {
89164       {
89165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89166       };
89167     } catch (...) {
89168       {
89169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89170       };
89171     }
89172   }
89173
89174 }
89175
89176
89177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
89178   void * jresult ;
89179   Dali::BaseHandle arg1 ;
89180   Dali::BaseHandle *argp1 ;
89181   Dali::Toolkit::GaussianBlurView result;
89182
89183   argp1 = (Dali::BaseHandle *)jarg1;
89184   if (!argp1) {
89185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89186     return 0;
89187   }
89188   arg1 = *argp1;
89189   {
89190     try {
89191       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
89192     } catch (std::out_of_range& e) {
89193       {
89194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89195       };
89196     } catch (std::exception& e) {
89197       {
89198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89199       };
89200     } catch (Dali::DaliException e) {
89201       {
89202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89203       };
89204     } catch (...) {
89205       {
89206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89207       };
89208     }
89209   }
89210
89211   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89212   return jresult;
89213 }
89214
89215
89216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
89217   void * jresult ;
89218   Dali::Toolkit::GaussianBlurView result;
89219
89220   {
89221     try {
89222       result = Dali::Toolkit::GaussianBlurView::New();
89223     } catch (std::out_of_range& e) {
89224       {
89225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89226       };
89227     } catch (std::exception& e) {
89228       {
89229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89230       };
89231     } catch (Dali::DaliException e) {
89232       {
89233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89234       };
89235     } catch (...) {
89236       {
89237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89238       };
89239     }
89240   }
89241
89242   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89243   return jresult;
89244 }
89245
89246
89247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
89248   void * jresult ;
89249   unsigned int arg1 ;
89250   float arg2 ;
89251   Dali::Pixel::Format arg3 ;
89252   float arg4 ;
89253   float arg5 ;
89254   bool arg6 ;
89255   Dali::Toolkit::GaussianBlurView result;
89256
89257   arg1 = (unsigned int)jarg1;
89258   arg2 = (float)jarg2;
89259   arg3 = (Dali::Pixel::Format)jarg3;
89260   arg4 = (float)jarg4;
89261   arg5 = (float)jarg5;
89262   arg6 = jarg6 ? true : false;
89263   {
89264     try {
89265       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
89266     } catch (std::out_of_range& e) {
89267       {
89268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89269       };
89270     } catch (std::exception& e) {
89271       {
89272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89273       };
89274     } catch (Dali::DaliException e) {
89275       {
89276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89277       };
89278     } catch (...) {
89279       {
89280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89281       };
89282     }
89283   }
89284
89285   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89286   return jresult;
89287 }
89288
89289
89290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
89291   void * jresult ;
89292   unsigned int arg1 ;
89293   float arg2 ;
89294   Dali::Pixel::Format arg3 ;
89295   float arg4 ;
89296   float arg5 ;
89297   Dali::Toolkit::GaussianBlurView result;
89298
89299   arg1 = (unsigned int)jarg1;
89300   arg2 = (float)jarg2;
89301   arg3 = (Dali::Pixel::Format)jarg3;
89302   arg4 = (float)jarg4;
89303   arg5 = (float)jarg5;
89304   {
89305     try {
89306       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
89307     } catch (std::out_of_range& e) {
89308       {
89309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89310       };
89311     } catch (std::exception& e) {
89312       {
89313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89314       };
89315     } catch (Dali::DaliException e) {
89316       {
89317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89318       };
89319     } catch (...) {
89320       {
89321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89322       };
89323     }
89324   }
89325
89326   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89327   return jresult;
89328 }
89329
89330
89331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
89332   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89333   Dali::Actor arg2 ;
89334   Dali::Actor *argp2 ;
89335
89336   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89337   argp2 = (Dali::Actor *)jarg2;
89338   if (!argp2) {
89339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89340     return ;
89341   }
89342   arg2 = *argp2;
89343   {
89344     try {
89345       (arg1)->Add(arg2);
89346     } catch (std::out_of_range& e) {
89347       {
89348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89349       };
89350     } catch (std::exception& e) {
89351       {
89352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89353       };
89354     } catch (Dali::DaliException e) {
89355       {
89356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89357       };
89358     } catch (...) {
89359       {
89360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89361       };
89362     }
89363   }
89364
89365 }
89366
89367
89368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
89369   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89370   Dali::Actor arg2 ;
89371   Dali::Actor *argp2 ;
89372
89373   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89374   argp2 = (Dali::Actor *)jarg2;
89375   if (!argp2) {
89376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89377     return ;
89378   }
89379   arg2 = *argp2;
89380   {
89381     try {
89382       (arg1)->Remove(arg2);
89383     } catch (std::out_of_range& e) {
89384       {
89385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89386       };
89387     } catch (std::exception& e) {
89388       {
89389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89390       };
89391     } catch (Dali::DaliException e) {
89392       {
89393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89394       };
89395     } catch (...) {
89396       {
89397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89398       };
89399     }
89400   }
89401
89402 }
89403
89404
89405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
89406   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89407
89408   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89409   {
89410     try {
89411       (arg1)->Activate();
89412     } catch (std::out_of_range& e) {
89413       {
89414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89415       };
89416     } catch (std::exception& e) {
89417       {
89418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89419       };
89420     } catch (Dali::DaliException e) {
89421       {
89422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89423       };
89424     } catch (...) {
89425       {
89426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89427       };
89428     }
89429   }
89430
89431 }
89432
89433
89434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
89435   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89436
89437   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89438   {
89439     try {
89440       (arg1)->ActivateOnce();
89441     } catch (std::out_of_range& e) {
89442       {
89443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89444       };
89445     } catch (std::exception& e) {
89446       {
89447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89448       };
89449     } catch (Dali::DaliException e) {
89450       {
89451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89452       };
89453     } catch (...) {
89454       {
89455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89456       };
89457     }
89458   }
89459
89460 }
89461
89462
89463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
89464   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89465
89466   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89467   {
89468     try {
89469       (arg1)->Deactivate();
89470     } catch (std::out_of_range& e) {
89471       {
89472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89473       };
89474     } catch (std::exception& e) {
89475       {
89476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89477       };
89478     } catch (Dali::DaliException e) {
89479       {
89480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89481       };
89482     } catch (...) {
89483       {
89484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89485       };
89486     }
89487   }
89488
89489 }
89490
89491
89492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
89493   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89494   Dali::Image arg2 ;
89495   Dali::FrameBufferImage arg3 ;
89496   Dali::Image *argp2 ;
89497   Dali::FrameBufferImage *argp3 ;
89498
89499   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89500   argp2 = (Dali::Image *)jarg2;
89501   if (!argp2) {
89502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
89503     return ;
89504   }
89505   arg2 = *argp2;
89506   argp3 = (Dali::FrameBufferImage *)jarg3;
89507   if (!argp3) {
89508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
89509     return ;
89510   }
89511   arg3 = *argp3;
89512   {
89513     try {
89514       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
89515     } catch (std::out_of_range& e) {
89516       {
89517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89518       };
89519     } catch (std::exception& e) {
89520       {
89521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89522       };
89523     } catch (Dali::DaliException e) {
89524       {
89525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89526       };
89527     } catch (...) {
89528       {
89529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89530       };
89531     }
89532   }
89533
89534 }
89535
89536
89537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
89538   int jresult ;
89539   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89540   Dali::Property::Index result;
89541
89542   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89543   {
89544     try {
89545       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
89546     } catch (std::out_of_range& e) {
89547       {
89548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89549       };
89550     } catch (std::exception& e) {
89551       {
89552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89553       };
89554     } catch (Dali::DaliException e) {
89555       {
89556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89557       };
89558     } catch (...) {
89559       {
89560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89561       };
89562     }
89563   }
89564
89565   jresult = result;
89566   return jresult;
89567 }
89568
89569
89570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
89571   void * jresult ;
89572   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89573   Dali::FrameBufferImage result;
89574
89575   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89576   {
89577     try {
89578       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
89579     } catch (std::out_of_range& e) {
89580       {
89581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89582       };
89583     } catch (std::exception& e) {
89584       {
89585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89586       };
89587     } catch (Dali::DaliException e) {
89588       {
89589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89590       };
89591     } catch (...) {
89592       {
89593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89594       };
89595     }
89596   }
89597
89598   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
89599   return jresult;
89600 }
89601
89602
89603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
89604   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89605   Dali::Vector4 *arg2 = 0 ;
89606
89607   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89608   arg2 = (Dali::Vector4 *)jarg2;
89609   if (!arg2) {
89610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
89611     return ;
89612   }
89613   {
89614     try {
89615       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
89616     } catch (std::out_of_range& e) {
89617       {
89618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89619       };
89620     } catch (std::exception& e) {
89621       {
89622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89623       };
89624     } catch (Dali::DaliException e) {
89625       {
89626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89627       };
89628     } catch (...) {
89629       {
89630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89631       };
89632     }
89633   }
89634
89635 }
89636
89637
89638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
89639   void * jresult ;
89640   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89641   Dali::Vector4 result;
89642
89643   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89644   {
89645     try {
89646       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
89647     } catch (std::out_of_range& e) {
89648       {
89649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89650       };
89651     } catch (std::exception& e) {
89652       {
89653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89654       };
89655     } catch (Dali::DaliException e) {
89656       {
89657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89658       };
89659     } catch (...) {
89660       {
89661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89662       };
89663     }
89664   }
89665
89666   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
89667   return jresult;
89668 }
89669
89670
89671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
89672   void * jresult ;
89673   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89674   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
89675
89676   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89677   {
89678     try {
89679       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
89680     } catch (std::out_of_range& e) {
89681       {
89682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89683       };
89684     } catch (std::exception& e) {
89685       {
89686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89687       };
89688     } catch (Dali::DaliException e) {
89689       {
89690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89691       };
89692     } catch (...) {
89693       {
89694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89695       };
89696     }
89697   }
89698
89699   jresult = (void *)result;
89700   return jresult;
89701 }
89702
89703
89704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
89705   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89706
89707   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89708   {
89709     try {
89710       delete arg1;
89711     } catch (std::out_of_range& e) {
89712       {
89713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89714       };
89715     } catch (std::exception& e) {
89716       {
89717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89718       };
89719     } catch (Dali::DaliException e) {
89720       {
89721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89722       };
89723     } catch (...) {
89724       {
89725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89726       };
89727     }
89728   }
89729
89730 }
89731
89732
89733 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
89734   unsigned int jresult ;
89735   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89736   unsigned int result;
89737
89738   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89739   {
89740     try {
89741       result = (unsigned int)(arg1)->GetNumberOfPages();
89742     } catch (std::out_of_range& e) {
89743       {
89744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89745       };
89746     } catch (std::exception& e) {
89747       {
89748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89749       };
89750     } catch (Dali::DaliException e) {
89751       {
89752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89753       };
89754     } catch (...) {
89755       {
89756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89757       };
89758     }
89759   }
89760
89761   jresult = result;
89762   return jresult;
89763 }
89764
89765
89766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
89767   void * jresult ;
89768   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89769   unsigned int arg2 ;
89770   Dali::Texture result;
89771
89772   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89773   arg2 = (unsigned int)jarg2;
89774   {
89775     try {
89776       result = (arg1)->NewPage(arg2);
89777     } catch (std::out_of_range& e) {
89778       {
89779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89780       };
89781     } catch (std::exception& e) {
89782       {
89783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89784       };
89785     } catch (Dali::DaliException e) {
89786       {
89787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89788       };
89789     } catch (...) {
89790       {
89791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89792       };
89793     }
89794   }
89795
89796   jresult = new Dali::Texture((const Dali::Texture &)result);
89797   return jresult;
89798 }
89799
89800
89801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
89802   int jresult ;
89803   int result;
89804
89805   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
89806   jresult = (int)result;
89807   return jresult;
89808 }
89809
89810
89811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
89812   int jresult ;
89813   int result;
89814
89815   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
89816   jresult = (int)result;
89817   return jresult;
89818 }
89819
89820
89821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
89822   int jresult ;
89823   int result;
89824
89825   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
89826   jresult = (int)result;
89827   return jresult;
89828 }
89829
89830
89831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
89832   void * jresult ;
89833   Dali::Toolkit::PageTurnView::Property *result = 0 ;
89834
89835   {
89836     try {
89837       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
89838     } catch (std::out_of_range& e) {
89839       {
89840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89841       };
89842     } catch (std::exception& e) {
89843       {
89844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89845       };
89846     } catch (Dali::DaliException e) {
89847       {
89848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89849       };
89850     } catch (...) {
89851       {
89852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89853       };
89854     }
89855   }
89856
89857   jresult = (void *)result;
89858   return jresult;
89859 }
89860
89861
89862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
89863   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
89864
89865   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
89866   {
89867     try {
89868       delete arg1;
89869     } catch (std::out_of_range& e) {
89870       {
89871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89872       };
89873     } catch (std::exception& e) {
89874       {
89875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89876       };
89877     } catch (Dali::DaliException e) {
89878       {
89879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89880       };
89881     } catch (...) {
89882       {
89883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89884       };
89885     }
89886   }
89887
89888 }
89889
89890
89891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
89892   void * jresult ;
89893   Dali::Toolkit::PageTurnView *result = 0 ;
89894
89895   {
89896     try {
89897       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
89898     } catch (std::out_of_range& e) {
89899       {
89900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89901       };
89902     } catch (std::exception& e) {
89903       {
89904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89905       };
89906     } catch (Dali::DaliException e) {
89907       {
89908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89909       };
89910     } catch (...) {
89911       {
89912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89913       };
89914     }
89915   }
89916
89917   jresult = (void *)result;
89918   return jresult;
89919 }
89920
89921
89922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
89923   void * jresult ;
89924   Dali::Toolkit::PageTurnView *arg1 = 0 ;
89925   Dali::Toolkit::PageTurnView *result = 0 ;
89926
89927   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89928   if (!arg1) {
89929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
89930     return 0;
89931   }
89932   {
89933     try {
89934       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
89935     } catch (std::out_of_range& e) {
89936       {
89937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89938       };
89939     } catch (std::exception& e) {
89940       {
89941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89942       };
89943     } catch (Dali::DaliException e) {
89944       {
89945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89946       };
89947     } catch (...) {
89948       {
89949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89950       };
89951     }
89952   }
89953
89954   jresult = (void *)result;
89955   return jresult;
89956 }
89957
89958
89959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
89960   void * jresult ;
89961   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89962   Dali::Toolkit::PageTurnView *arg2 = 0 ;
89963   Dali::Toolkit::PageTurnView *result = 0 ;
89964
89965   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89966   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
89967   if (!arg2) {
89968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
89969     return 0;
89970   }
89971   {
89972     try {
89973       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
89974     } catch (std::out_of_range& e) {
89975       {
89976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89977       };
89978     } catch (std::exception& e) {
89979       {
89980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89981       };
89982     } catch (Dali::DaliException e) {
89983       {
89984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89985       };
89986     } catch (...) {
89987       {
89988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89989       };
89990     }
89991   }
89992
89993   jresult = (void *)result;
89994   return jresult;
89995 }
89996
89997
89998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
89999   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90000
90001   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90002   {
90003     try {
90004       delete arg1;
90005     } catch (std::out_of_range& e) {
90006       {
90007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90008       };
90009     } catch (std::exception& e) {
90010       {
90011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90012       };
90013     } catch (Dali::DaliException e) {
90014       {
90015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90016       };
90017     } catch (...) {
90018       {
90019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90020       };
90021     }
90022   }
90023
90024 }
90025
90026
90027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
90028   void * jresult ;
90029   Dali::BaseHandle arg1 ;
90030   Dali::BaseHandle *argp1 ;
90031   Dali::Toolkit::PageTurnView result;
90032
90033   argp1 = (Dali::BaseHandle *)jarg1;
90034   if (!argp1) {
90035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90036     return 0;
90037   }
90038   arg1 = *argp1;
90039   {
90040     try {
90041       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
90042     } catch (std::out_of_range& e) {
90043       {
90044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90045       };
90046     } catch (std::exception& e) {
90047       {
90048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90049       };
90050     } catch (Dali::DaliException e) {
90051       {
90052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90053       };
90054     } catch (...) {
90055       {
90056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90057       };
90058     }
90059   }
90060
90061   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
90062   return jresult;
90063 }
90064
90065
90066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
90067   void * jresult ;
90068   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90069   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
90070
90071   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90072   {
90073     try {
90074       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
90075     } catch (std::out_of_range& e) {
90076       {
90077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90078       };
90079     } catch (std::exception& e) {
90080       {
90081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90082       };
90083     } catch (Dali::DaliException e) {
90084       {
90085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90086       };
90087     } catch (...) {
90088       {
90089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90090       };
90091     }
90092   }
90093
90094   jresult = (void *)result;
90095   return jresult;
90096 }
90097
90098
90099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
90100   void * jresult ;
90101   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90102   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
90103
90104   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90105   {
90106     try {
90107       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
90108     } catch (std::out_of_range& e) {
90109       {
90110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90111       };
90112     } catch (std::exception& e) {
90113       {
90114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90115       };
90116     } catch (Dali::DaliException e) {
90117       {
90118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90119       };
90120     } catch (...) {
90121       {
90122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90123       };
90124     }
90125   }
90126
90127   jresult = (void *)result;
90128   return jresult;
90129 }
90130
90131
90132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
90133   void * jresult ;
90134   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90135   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
90136
90137   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90138   {
90139     try {
90140       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
90141     } catch (std::out_of_range& e) {
90142       {
90143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90144       };
90145     } catch (std::exception& e) {
90146       {
90147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90148       };
90149     } catch (Dali::DaliException e) {
90150       {
90151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90152       };
90153     } catch (...) {
90154       {
90155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90156       };
90157     }
90158   }
90159
90160   jresult = (void *)result;
90161   return jresult;
90162 }
90163
90164
90165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
90166   void * jresult ;
90167   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90168   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
90169
90170   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90171   {
90172     try {
90173       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
90174     } catch (std::out_of_range& e) {
90175       {
90176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90177       };
90178     } catch (std::exception& e) {
90179       {
90180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90181       };
90182     } catch (Dali::DaliException e) {
90183       {
90184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90185       };
90186     } catch (...) {
90187       {
90188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90189       };
90190     }
90191   }
90192
90193   jresult = (void *)result;
90194   return jresult;
90195 }
90196
90197
90198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
90199   void * jresult ;
90200   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90201
90202   {
90203     try {
90204       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
90205     } catch (std::out_of_range& e) {
90206       {
90207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90208       };
90209     } catch (std::exception& e) {
90210       {
90211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90212       };
90213     } catch (Dali::DaliException e) {
90214       {
90215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90216       };
90217     } catch (...) {
90218       {
90219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90220       };
90221     }
90222   }
90223
90224   jresult = (void *)result;
90225   return jresult;
90226 }
90227
90228
90229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
90230   void * jresult ;
90231   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
90232   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90233
90234   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90235   if (!arg1) {
90236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90237     return 0;
90238   }
90239   {
90240     try {
90241       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
90242     } catch (std::out_of_range& e) {
90243       {
90244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90245       };
90246     } catch (std::exception& e) {
90247       {
90248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90249       };
90250     } catch (Dali::DaliException e) {
90251       {
90252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90253       };
90254     } catch (...) {
90255       {
90256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90257       };
90258     }
90259   }
90260
90261   jresult = (void *)result;
90262   return jresult;
90263 }
90264
90265
90266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
90267   void * jresult ;
90268   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90269   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
90270   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90271
90272   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90273   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
90274   if (!arg2) {
90275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90276     return 0;
90277   }
90278   {
90279     try {
90280       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
90281     } catch (std::out_of_range& e) {
90282       {
90283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90284       };
90285     } catch (std::exception& e) {
90286       {
90287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90288       };
90289     } catch (Dali::DaliException e) {
90290       {
90291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90292       };
90293     } catch (...) {
90294       {
90295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90296       };
90297     }
90298   }
90299
90300   jresult = (void *)result;
90301   return jresult;
90302 }
90303
90304
90305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
90306   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90307
90308   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90309   {
90310     try {
90311       delete arg1;
90312     } catch (std::out_of_range& e) {
90313       {
90314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90315       };
90316     } catch (std::exception& e) {
90317       {
90318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90319       };
90320     } catch (Dali::DaliException e) {
90321       {
90322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90323       };
90324     } catch (...) {
90325       {
90326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90327       };
90328     }
90329   }
90330
90331 }
90332
90333
90334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
90335   void * jresult ;
90336   Dali::Toolkit::PageFactory *arg1 = 0 ;
90337   Dali::Vector2 *arg2 = 0 ;
90338   Dali::Toolkit::PageTurnLandscapeView result;
90339
90340   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90341   if (!arg1) {
90342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90343     return 0;
90344   }
90345   arg2 = (Dali::Vector2 *)jarg2;
90346   if (!arg2) {
90347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90348     return 0;
90349   }
90350   {
90351     try {
90352       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
90353     } catch (std::out_of_range& e) {
90354       {
90355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90356       };
90357     } catch (std::exception& e) {
90358       {
90359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90360       };
90361     } catch (Dali::DaliException e) {
90362       {
90363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90364       };
90365     } catch (...) {
90366       {
90367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90368       };
90369     }
90370   }
90371
90372   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90373   return jresult;
90374 }
90375
90376
90377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
90378   void * jresult ;
90379   Dali::BaseHandle arg1 ;
90380   Dali::BaseHandle *argp1 ;
90381   Dali::Toolkit::PageTurnLandscapeView result;
90382
90383   argp1 = (Dali::BaseHandle *)jarg1;
90384   if (!argp1) {
90385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90386     return 0;
90387   }
90388   arg1 = *argp1;
90389   {
90390     try {
90391       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
90392     } catch (std::out_of_range& e) {
90393       {
90394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90395       };
90396     } catch (std::exception& e) {
90397       {
90398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90399       };
90400     } catch (Dali::DaliException e) {
90401       {
90402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90403       };
90404     } catch (...) {
90405       {
90406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90407       };
90408     }
90409   }
90410
90411   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90412   return jresult;
90413 }
90414
90415
90416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
90417   void * jresult ;
90418   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90419
90420   {
90421     try {
90422       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
90423     } catch (std::out_of_range& e) {
90424       {
90425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90426       };
90427     } catch (std::exception& e) {
90428       {
90429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90430       };
90431     } catch (Dali::DaliException e) {
90432       {
90433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90434       };
90435     } catch (...) {
90436       {
90437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90438       };
90439     }
90440   }
90441
90442   jresult = (void *)result;
90443   return jresult;
90444 }
90445
90446
90447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
90448   void * jresult ;
90449   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
90450   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90451
90452   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90453   if (!arg1) {
90454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90455     return 0;
90456   }
90457   {
90458     try {
90459       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
90460     } catch (std::out_of_range& e) {
90461       {
90462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90463       };
90464     } catch (std::exception& e) {
90465       {
90466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90467       };
90468     } catch (Dali::DaliException e) {
90469       {
90470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90471       };
90472     } catch (...) {
90473       {
90474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90475       };
90476     }
90477   }
90478
90479   jresult = (void *)result;
90480   return jresult;
90481 }
90482
90483
90484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
90485   void * jresult ;
90486   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90487   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
90488   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90489
90490   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90491   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
90492   if (!arg2) {
90493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90494     return 0;
90495   }
90496   {
90497     try {
90498       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
90499     } catch (std::out_of_range& e) {
90500       {
90501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90502       };
90503     } catch (std::exception& e) {
90504       {
90505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90506       };
90507     } catch (Dali::DaliException e) {
90508       {
90509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90510       };
90511     } catch (...) {
90512       {
90513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90514       };
90515     }
90516   }
90517
90518   jresult = (void *)result;
90519   return jresult;
90520 }
90521
90522
90523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
90524   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90525
90526   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90527   {
90528     try {
90529       delete arg1;
90530     } catch (std::out_of_range& e) {
90531       {
90532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90533       };
90534     } catch (std::exception& e) {
90535       {
90536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90537       };
90538     } catch (Dali::DaliException e) {
90539       {
90540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90541       };
90542     } catch (...) {
90543       {
90544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90545       };
90546     }
90547   }
90548
90549 }
90550
90551
90552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
90553   void * jresult ;
90554   Dali::Toolkit::PageFactory *arg1 = 0 ;
90555   Dali::Vector2 *arg2 = 0 ;
90556   Dali::Toolkit::PageTurnPortraitView result;
90557
90558   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90559   if (!arg1) {
90560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90561     return 0;
90562   }
90563   arg2 = (Dali::Vector2 *)jarg2;
90564   if (!arg2) {
90565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90566     return 0;
90567   }
90568   {
90569     try {
90570       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
90571     } catch (std::out_of_range& e) {
90572       {
90573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90574       };
90575     } catch (std::exception& e) {
90576       {
90577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90578       };
90579     } catch (Dali::DaliException e) {
90580       {
90581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90582       };
90583     } catch (...) {
90584       {
90585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90586       };
90587     }
90588   }
90589
90590   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
90591   return jresult;
90592 }
90593
90594
90595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
90596   void * jresult ;
90597   Dali::BaseHandle arg1 ;
90598   Dali::BaseHandle *argp1 ;
90599   Dali::Toolkit::PageTurnPortraitView result;
90600
90601   argp1 = (Dali::BaseHandle *)jarg1;
90602   if (!argp1) {
90603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90604     return 0;
90605   }
90606   arg1 = *argp1;
90607   {
90608     try {
90609       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
90610     } catch (std::out_of_range& e) {
90611       {
90612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90613       };
90614     } catch (std::exception& e) {
90615       {
90616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90617       };
90618     } catch (Dali::DaliException e) {
90619       {
90620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90621       };
90622     } catch (...) {
90623       {
90624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90625       };
90626     }
90627   }
90628
90629   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
90630   return jresult;
90631 }
90632
90633
90634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
90635   int jresult ;
90636   int result;
90637
90638   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
90639   jresult = (int)result;
90640   return jresult;
90641 }
90642
90643
90644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
90645   int jresult ;
90646   int result;
90647
90648   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
90649   jresult = (int)result;
90650   return jresult;
90651 }
90652
90653
90654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
90655   int jresult ;
90656   int result;
90657
90658   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
90659   jresult = (int)result;
90660   return jresult;
90661 }
90662
90663
90664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
90665   void * jresult ;
90666   Dali::Toolkit::ToggleButton::Property *result = 0 ;
90667
90668   {
90669     try {
90670       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
90671     } catch (std::out_of_range& e) {
90672       {
90673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90674       };
90675     } catch (std::exception& e) {
90676       {
90677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90678       };
90679     } catch (Dali::DaliException e) {
90680       {
90681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90682       };
90683     } catch (...) {
90684       {
90685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90686       };
90687     }
90688   }
90689
90690   jresult = (void *)result;
90691   return jresult;
90692 }
90693
90694
90695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
90696   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
90697
90698   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
90699   {
90700     try {
90701       delete arg1;
90702     } catch (std::out_of_range& e) {
90703       {
90704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90705       };
90706     } catch (std::exception& e) {
90707       {
90708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90709       };
90710     } catch (Dali::DaliException e) {
90711       {
90712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90713       };
90714     } catch (...) {
90715       {
90716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90717       };
90718     }
90719   }
90720
90721 }
90722
90723
90724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
90725   void * jresult ;
90726   Dali::Toolkit::ToggleButton *result = 0 ;
90727
90728   {
90729     try {
90730       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
90731     } catch (std::out_of_range& e) {
90732       {
90733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90734       };
90735     } catch (std::exception& e) {
90736       {
90737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90738       };
90739     } catch (Dali::DaliException e) {
90740       {
90741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90742       };
90743     } catch (...) {
90744       {
90745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90746       };
90747     }
90748   }
90749
90750   jresult = (void *)result;
90751   return jresult;
90752 }
90753
90754
90755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
90756   void * jresult ;
90757   Dali::Toolkit::ToggleButton *arg1 = 0 ;
90758   Dali::Toolkit::ToggleButton *result = 0 ;
90759
90760   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90761   if (!arg1) {
90762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
90763     return 0;
90764   }
90765   {
90766     try {
90767       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
90768     } catch (std::out_of_range& e) {
90769       {
90770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90771       };
90772     } catch (std::exception& e) {
90773       {
90774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90775       };
90776     } catch (Dali::DaliException e) {
90777       {
90778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90779       };
90780     } catch (...) {
90781       {
90782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90783       };
90784     }
90785   }
90786
90787   jresult = (void *)result;
90788   return jresult;
90789 }
90790
90791
90792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
90793   void * jresult ;
90794   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
90795   Dali::Toolkit::ToggleButton *arg2 = 0 ;
90796   Dali::Toolkit::ToggleButton *result = 0 ;
90797
90798   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90799   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
90800   if (!arg2) {
90801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
90802     return 0;
90803   }
90804   {
90805     try {
90806       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
90807     } catch (std::out_of_range& e) {
90808       {
90809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90810       };
90811     } catch (std::exception& e) {
90812       {
90813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90814       };
90815     } catch (Dali::DaliException e) {
90816       {
90817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90818       };
90819     } catch (...) {
90820       {
90821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90822       };
90823     }
90824   }
90825
90826   jresult = (void *)result;
90827   return jresult;
90828 }
90829
90830
90831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
90832   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
90833
90834   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90835   {
90836     try {
90837       delete arg1;
90838     } catch (std::out_of_range& e) {
90839       {
90840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90841       };
90842     } catch (std::exception& e) {
90843       {
90844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90845       };
90846     } catch (Dali::DaliException e) {
90847       {
90848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90849       };
90850     } catch (...) {
90851       {
90852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90853       };
90854     }
90855   }
90856
90857 }
90858
90859
90860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
90861   void * jresult ;
90862   Dali::Toolkit::ToggleButton result;
90863
90864   {
90865     try {
90866       result = Dali::Toolkit::ToggleButton::New();
90867     } catch (std::out_of_range& e) {
90868       {
90869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90870       };
90871     } catch (std::exception& e) {
90872       {
90873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90874       };
90875     } catch (Dali::DaliException e) {
90876       {
90877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90878       };
90879     } catch (...) {
90880       {
90881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90882       };
90883     }
90884   }
90885
90886   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
90887   return jresult;
90888 }
90889
90890
90891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
90892   void * jresult ;
90893   Dali::BaseHandle arg1 ;
90894   Dali::BaseHandle *argp1 ;
90895   Dali::Toolkit::ToggleButton result;
90896
90897   argp1 = (Dali::BaseHandle *)jarg1;
90898   if (!argp1) {
90899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90900     return 0;
90901   }
90902   arg1 = *argp1;
90903   {
90904     try {
90905       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
90906     } catch (std::out_of_range& e) {
90907       {
90908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90909       };
90910     } catch (std::exception& e) {
90911       {
90912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90913       };
90914     } catch (Dali::DaliException e) {
90915       {
90916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90917       };
90918     } catch (...) {
90919       {
90920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90921       };
90922     }
90923   }
90924
90925   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
90926   return jresult;
90927 }
90928
90929
90930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
90931   void * jresult ;
90932   Dali::Toolkit::Visual::Base *result = 0 ;
90933
90934   {
90935     try {
90936       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
90937     } catch (std::out_of_range& e) {
90938       {
90939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90940       };
90941     } catch (std::exception& e) {
90942       {
90943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90944       };
90945     } catch (Dali::DaliException e) {
90946       {
90947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90948       };
90949     } catch (...) {
90950       {
90951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90952       };
90953     }
90954   }
90955
90956   jresult = (void *)result;
90957   return jresult;
90958 }
90959
90960
90961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
90962   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90963
90964   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90965   {
90966     try {
90967       delete arg1;
90968     } catch (std::out_of_range& e) {
90969       {
90970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90971       };
90972     } catch (std::exception& e) {
90973       {
90974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90975       };
90976     } catch (Dali::DaliException e) {
90977       {
90978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90979       };
90980     } catch (...) {
90981       {
90982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90983       };
90984     }
90985   }
90986
90987 }
90988
90989
90990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
90991   void * jresult ;
90992   Dali::Toolkit::Visual::Base *arg1 = 0 ;
90993   Dali::Toolkit::Visual::Base *result = 0 ;
90994
90995   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90996   if (!arg1) {
90997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
90998     return 0;
90999   }
91000   {
91001     try {
91002       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
91003     } catch (std::out_of_range& e) {
91004       {
91005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91006       };
91007     } catch (std::exception& e) {
91008       {
91009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91010       };
91011     } catch (Dali::DaliException e) {
91012       {
91013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91014       };
91015     } catch (...) {
91016       {
91017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91018       };
91019     }
91020   }
91021
91022   jresult = (void *)result;
91023   return jresult;
91024 }
91025
91026
91027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
91028   void * jresult ;
91029   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91030   Dali::Toolkit::Visual::Base *arg2 = 0 ;
91031   Dali::Toolkit::Visual::Base *result = 0 ;
91032
91033   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91034   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
91035   if (!arg2) {
91036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
91037     return 0;
91038   }
91039   {
91040     try {
91041       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
91042     } catch (std::out_of_range& e) {
91043       {
91044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91045       };
91046     } catch (std::exception& e) {
91047       {
91048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91049       };
91050     } catch (Dali::DaliException e) {
91051       {
91052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91053       };
91054     } catch (...) {
91055       {
91056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91057       };
91058     }
91059   }
91060
91061   jresult = (void *)result;
91062   return jresult;
91063 }
91064
91065
91066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
91067   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91068   std::string *arg2 = 0 ;
91069
91070   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91071   if (!jarg2) {
91072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91073     return ;
91074   }
91075   std::string arg2_str(jarg2);
91076   arg2 = &arg2_str;
91077   {
91078     try {
91079       (arg1)->SetName((std::string const &)*arg2);
91080     } catch (std::out_of_range& e) {
91081       {
91082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91083       };
91084     } catch (std::exception& e) {
91085       {
91086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91087       };
91088     } catch (Dali::DaliException e) {
91089       {
91090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91091       };
91092     } catch (...) {
91093       {
91094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91095       };
91096     }
91097   }
91098
91099
91100   //argout typemap for const std::string&
91101
91102 }
91103
91104
91105 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
91106   char * jresult ;
91107   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91108   std::string *result = 0 ;
91109
91110   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91111   {
91112     try {
91113       result = (std::string *) &(arg1)->GetName();
91114     } catch (std::out_of_range& e) {
91115       {
91116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91117       };
91118     } catch (std::exception& e) {
91119       {
91120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91121       };
91122     } catch (Dali::DaliException e) {
91123       {
91124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91125       };
91126     } catch (...) {
91127       {
91128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91129       };
91130     }
91131   }
91132
91133   jresult = SWIG_csharp_string_callback(result->c_str());
91134   return jresult;
91135 }
91136
91137
91138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
91139   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91140   Dali::Property::Map *arg2 = 0 ;
91141   Dali::Size arg3 ;
91142   Dali::Size *argp3 ;
91143
91144   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91145   arg2 = (Dali::Property::Map *)jarg2;
91146   if (!arg2) {
91147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
91148     return ;
91149   }
91150   argp3 = (Dali::Size *)jarg3;
91151   if (!argp3) {
91152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
91153     return ;
91154   }
91155   arg3 = *argp3;
91156   {
91157     try {
91158       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
91159     } catch (std::out_of_range& e) {
91160       {
91161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91162       };
91163     } catch (std::exception& e) {
91164       {
91165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91166       };
91167     } catch (Dali::DaliException e) {
91168       {
91169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91170       };
91171     } catch (...) {
91172       {
91173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91174       };
91175     }
91176   }
91177
91178 }
91179
91180
91181 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
91182   float jresult ;
91183   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91184   float arg2 ;
91185   float result;
91186
91187   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91188   arg2 = (float)jarg2;
91189   {
91190     try {
91191       result = (float)(arg1)->GetHeightForWidth(arg2);
91192     } catch (std::out_of_range& e) {
91193       {
91194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91195       };
91196     } catch (std::exception& e) {
91197       {
91198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91199       };
91200     } catch (Dali::DaliException e) {
91201       {
91202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91203       };
91204     } catch (...) {
91205       {
91206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91207       };
91208     }
91209   }
91210
91211   jresult = result;
91212   return jresult;
91213 }
91214
91215
91216 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
91217   float jresult ;
91218   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91219   float arg2 ;
91220   float result;
91221
91222   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91223   arg2 = (float)jarg2;
91224   {
91225     try {
91226       result = (float)(arg1)->GetWidthForHeight(arg2);
91227     } catch (std::out_of_range& e) {
91228       {
91229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91230       };
91231     } catch (std::exception& e) {
91232       {
91233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91234       };
91235     } catch (Dali::DaliException e) {
91236       {
91237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91238       };
91239     } catch (...) {
91240       {
91241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91242       };
91243     }
91244   }
91245
91246   jresult = result;
91247   return jresult;
91248 }
91249
91250
91251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
91252   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91253   Dali::Vector2 *arg2 = 0 ;
91254
91255   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91256   arg2 = (Dali::Vector2 *)jarg2;
91257   if (!arg2) {
91258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
91259     return ;
91260   }
91261   {
91262     try {
91263       (arg1)->GetNaturalSize(*arg2);
91264     } catch (std::out_of_range& e) {
91265       {
91266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91267       };
91268     } catch (std::exception& e) {
91269       {
91270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91271       };
91272     } catch (Dali::DaliException e) {
91273       {
91274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91275       };
91276     } catch (...) {
91277       {
91278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91279       };
91280     }
91281   }
91282
91283 }
91284
91285
91286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
91287   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91288   float arg2 ;
91289
91290   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91291   arg2 = (int)jarg2;
91292   {
91293     try {
91294       (arg1)->SetDepthIndex(arg2);
91295     } catch (std::out_of_range& e) {
91296       {
91297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91298       };
91299     } catch (std::exception& e) {
91300       {
91301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91302       };
91303     } catch (Dali::DaliException e) {
91304       {
91305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91306       };
91307     } catch (...) {
91308       {
91309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91310       };
91311     }
91312   }
91313
91314 }
91315
91316
91317 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
91318   int jresult ;
91319   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91320   int result;
91321
91322   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91323   {
91324     try {
91325       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
91326     } catch (std::out_of_range& e) {
91327       {
91328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91329       };
91330     } catch (std::exception& e) {
91331       {
91332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91333       };
91334     } catch (Dali::DaliException e) {
91335       {
91336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91337       };
91338     } catch (...) {
91339       {
91340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91341       };
91342     }
91343   }
91344
91345   jresult = result;
91346   return jresult;
91347 }
91348
91349
91350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
91351   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91352   Dali::Property::Map *arg2 = 0 ;
91353
91354   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91355   arg2 = (Dali::Property::Map *)jarg2;
91356   if (!arg2) {
91357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
91358     return ;
91359   }
91360   {
91361     try {
91362       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
91363     } catch (std::out_of_range& e) {
91364       {
91365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91366       };
91367     } catch (std::exception& e) {
91368       {
91369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91370       };
91371     } catch (Dali::DaliException e) {
91372       {
91373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91374       };
91375     } catch (...) {
91376       {
91377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91378       };
91379     }
91380   }
91381
91382 }
91383
91384
91385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_2(void * jarg1) {
91386   void * jresult ;
91387   Dali::Toolkit::Internal::Visual::Base *arg1 = (Dali::Toolkit::Internal::Visual::Base *) 0 ;
91388   Dali::Toolkit::Visual::Base *result = 0 ;
91389
91390   arg1 = (Dali::Toolkit::Internal::Visual::Base *)jarg1;
91391   {
91392     try {
91393       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base(arg1);
91394     } catch (std::out_of_range& e) {
91395       {
91396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91397       };
91398     } catch (std::exception& e) {
91399       {
91400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91401       };
91402     } catch (Dali::DaliException e) {
91403       {
91404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91405       };
91406     } catch (...) {
91407       {
91408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91409       };
91410     }
91411   }
91412
91413   jresult = (void *)result;
91414   return jresult;
91415 }
91416
91417
91418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
91419   void * jresult ;
91420   Dali::Toolkit::VisualFactory result;
91421
91422   {
91423     try {
91424       result = Dali::Toolkit::VisualFactory::Get();
91425     } catch (std::out_of_range& e) {
91426       {
91427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91428       };
91429     } catch (std::exception& e) {
91430       {
91431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91432       };
91433     } catch (Dali::DaliException e) {
91434       {
91435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91436       };
91437     } catch (...) {
91438       {
91439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91440       };
91441     }
91442   }
91443
91444   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
91445   return jresult;
91446 }
91447
91448
91449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
91450   void * jresult ;
91451   Dali::Toolkit::VisualFactory *result = 0 ;
91452
91453   {
91454     try {
91455       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
91456     } catch (std::out_of_range& e) {
91457       {
91458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91459       };
91460     } catch (std::exception& e) {
91461       {
91462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91463       };
91464     } catch (Dali::DaliException e) {
91465       {
91466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91467       };
91468     } catch (...) {
91469       {
91470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91471       };
91472     }
91473   }
91474
91475   jresult = (void *)result;
91476   return jresult;
91477 }
91478
91479
91480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
91481   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91482
91483   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91484   {
91485     try {
91486       delete arg1;
91487     } catch (std::out_of_range& e) {
91488       {
91489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91490       };
91491     } catch (std::exception& e) {
91492       {
91493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91494       };
91495     } catch (Dali::DaliException e) {
91496       {
91497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91498       };
91499     } catch (...) {
91500       {
91501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91502       };
91503     }
91504   }
91505
91506 }
91507
91508
91509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
91510   void * jresult ;
91511   Dali::Toolkit::VisualFactory *arg1 = 0 ;
91512   Dali::Toolkit::VisualFactory *result = 0 ;
91513
91514   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91515   if (!arg1) {
91516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91517     return 0;
91518   }
91519   {
91520     try {
91521       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
91522     } catch (std::out_of_range& e) {
91523       {
91524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91525       };
91526     } catch (std::exception& e) {
91527       {
91528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91529       };
91530     } catch (Dali::DaliException e) {
91531       {
91532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91533       };
91534     } catch (...) {
91535       {
91536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91537       };
91538     }
91539   }
91540
91541   jresult = (void *)result;
91542   return jresult;
91543 }
91544
91545
91546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
91547   void * jresult ;
91548   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91549   Dali::Toolkit::VisualFactory *arg2 = 0 ;
91550   Dali::Toolkit::VisualFactory *result = 0 ;
91551
91552   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91553   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
91554   if (!arg2) {
91555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91556     return 0;
91557   }
91558   {
91559     try {
91560       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
91561     } catch (std::out_of_range& e) {
91562       {
91563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91564       };
91565     } catch (std::exception& e) {
91566       {
91567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91568       };
91569     } catch (Dali::DaliException e) {
91570       {
91571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91572       };
91573     } catch (...) {
91574       {
91575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91576       };
91577     }
91578   }
91579
91580   jresult = (void *)result;
91581   return jresult;
91582 }
91583
91584
91585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
91586   void * jresult ;
91587   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91588   Dali::Property::Map *arg2 = 0 ;
91589   Dali::Toolkit::Visual::Base result;
91590
91591   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91592   arg2 = (Dali::Property::Map *)jarg2;
91593   if (!arg2) {
91594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
91595     return 0;
91596   }
91597   {
91598     try {
91599       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
91600     } catch (std::out_of_range& e) {
91601       {
91602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91603       };
91604     } catch (std::exception& e) {
91605       {
91606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91607       };
91608     } catch (Dali::DaliException e) {
91609       {
91610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91611       };
91612     } catch (...) {
91613       {
91614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91615       };
91616     }
91617   }
91618
91619   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91620   return jresult;
91621 }
91622
91623
91624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
91625   void * jresult ;
91626   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91627   Dali::Image *arg2 = 0 ;
91628   Dali::Toolkit::Visual::Base result;
91629
91630   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91631   arg2 = (Dali::Image *)jarg2;
91632   if (!arg2) {
91633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
91634     return 0;
91635   }
91636   {
91637     try {
91638       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
91639     } catch (std::out_of_range& e) {
91640       {
91641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91642       };
91643     } catch (std::exception& e) {
91644       {
91645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91646       };
91647     } catch (Dali::DaliException e) {
91648       {
91649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91650       };
91651     } catch (...) {
91652       {
91653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91654       };
91655     }
91656   }
91657
91658   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91659   return jresult;
91660 }
91661
91662
91663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
91664   void * jresult ;
91665   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91666   std::string *arg2 = 0 ;
91667   Dali::ImageDimensions arg3 ;
91668   Dali::ImageDimensions *argp3 ;
91669   Dali::Toolkit::Visual::Base result;
91670
91671   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91672   if (!jarg2) {
91673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91674     return 0;
91675   }
91676   std::string arg2_str(jarg2);
91677   arg2 = &arg2_str;
91678   argp3 = (Dali::ImageDimensions *)jarg3;
91679   if (!argp3) {
91680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91681     return 0;
91682   }
91683   arg3 = *argp3;
91684   {
91685     try {
91686       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
91687     } catch (std::out_of_range& e) {
91688       {
91689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91690       };
91691     } catch (std::exception& e) {
91692       {
91693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91694       };
91695     } catch (Dali::DaliException e) {
91696       {
91697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91698       };
91699     } catch (...) {
91700       {
91701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91702       };
91703     }
91704   }
91705
91706   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91707
91708   //argout typemap for const std::string&
91709
91710   return jresult;
91711 }
91712
91713
91714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
91715   void * jresult ;
91716   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91717
91718   {
91719     try {
91720       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
91721     } catch (std::out_of_range& e) {
91722       {
91723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91724       };
91725     } catch (std::exception& e) {
91726       {
91727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91728       };
91729     } catch (Dali::DaliException e) {
91730       {
91731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91732       };
91733     } catch (...) {
91734       {
91735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91736       };
91737     }
91738   }
91739
91740   jresult = (void *)result;
91741   return jresult;
91742 }
91743
91744
91745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
91746   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91747
91748   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91749   {
91750     try {
91751       delete arg1;
91752     } catch (std::out_of_range& e) {
91753       {
91754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91755       };
91756     } catch (std::exception& e) {
91757       {
91758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91759       };
91760     } catch (Dali::DaliException e) {
91761       {
91762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91763       };
91764     } catch (...) {
91765       {
91766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91767       };
91768     }
91769   }
91770
91771 }
91772
91773
91774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
91775   void * jresult ;
91776   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
91777   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91778
91779   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91780   if (!arg1) {
91781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
91782     return 0;
91783   }
91784   {
91785     try {
91786       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
91787     } catch (std::out_of_range& e) {
91788       {
91789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91790       };
91791     } catch (std::exception& e) {
91792       {
91793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91794       };
91795     } catch (Dali::DaliException e) {
91796       {
91797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91798       };
91799     } catch (...) {
91800       {
91801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91802       };
91803     }
91804   }
91805
91806   jresult = (void *)result;
91807   return jresult;
91808 }
91809
91810
91811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
91812   void * jresult ;
91813   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91814   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
91815   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91816
91817   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91818   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
91819   if (!arg2) {
91820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
91821     return 0;
91822   }
91823   {
91824     try {
91825       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
91826     } catch (std::out_of_range& e) {
91827       {
91828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91829       };
91830     } catch (std::exception& e) {
91831       {
91832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91833       };
91834     } catch (Dali::DaliException e) {
91835       {
91836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91837       };
91838     } catch (...) {
91839       {
91840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91841       };
91842     }
91843   }
91844
91845   jresult = (void *)result;
91846   return jresult;
91847 }
91848
91849
91850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
91851   void * jresult ;
91852   Dali::Toolkit::AsyncImageLoader result;
91853
91854   {
91855     try {
91856       result = Dali::Toolkit::AsyncImageLoader::New();
91857     } catch (std::out_of_range& e) {
91858       {
91859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91860       };
91861     } catch (std::exception& e) {
91862       {
91863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91864       };
91865     } catch (Dali::DaliException e) {
91866       {
91867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91868       };
91869     } catch (...) {
91870       {
91871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91872       };
91873     }
91874   }
91875
91876   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
91877   return jresult;
91878 }
91879
91880
91881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
91882   void * jresult ;
91883   Dali::BaseHandle arg1 ;
91884   Dali::BaseHandle *argp1 ;
91885   Dali::Toolkit::AsyncImageLoader result;
91886
91887   argp1 = (Dali::BaseHandle *)jarg1;
91888   if (!argp1) {
91889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
91890     return 0;
91891   }
91892   arg1 = *argp1;
91893   {
91894     try {
91895       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
91896     } catch (std::out_of_range& e) {
91897       {
91898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91899       };
91900     } catch (std::exception& e) {
91901       {
91902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91903       };
91904     } catch (Dali::DaliException e) {
91905       {
91906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91907       };
91908     } catch (...) {
91909       {
91910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91911       };
91912     }
91913   }
91914
91915   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
91916   return jresult;
91917 }
91918
91919
91920 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
91921   unsigned int jresult ;
91922   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91923   std::string *arg2 = 0 ;
91924   uint32_t result;
91925
91926   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91927   if (!jarg2) {
91928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91929     return 0;
91930   }
91931   std::string arg2_str(jarg2);
91932   arg2 = &arg2_str;
91933   {
91934     try {
91935       result = (arg1)->Load((std::string const &)*arg2);
91936     } catch (std::out_of_range& e) {
91937       {
91938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91939       };
91940     } catch (std::exception& e) {
91941       {
91942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91943       };
91944     } catch (Dali::DaliException e) {
91945       {
91946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91947       };
91948     } catch (...) {
91949       {
91950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91951       };
91952     }
91953   }
91954
91955   jresult = result;
91956
91957   //argout typemap for const std::string&
91958
91959   return jresult;
91960 }
91961
91962
91963 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
91964   unsigned int jresult ;
91965   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91966   std::string *arg2 = 0 ;
91967   Dali::ImageDimensions arg3 ;
91968   Dali::ImageDimensions *argp3 ;
91969   uint32_t result;
91970
91971   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91972   if (!jarg2) {
91973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91974     return 0;
91975   }
91976   std::string arg2_str(jarg2);
91977   arg2 = &arg2_str;
91978   argp3 = (Dali::ImageDimensions *)jarg3;
91979   if (!argp3) {
91980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91981     return 0;
91982   }
91983   arg3 = *argp3;
91984   {
91985     try {
91986       result = (arg1)->Load((std::string const &)*arg2,arg3);
91987     } catch (std::out_of_range& e) {
91988       {
91989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91990       };
91991     } catch (std::exception& e) {
91992       {
91993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91994       };
91995     } catch (Dali::DaliException e) {
91996       {
91997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91998       };
91999     } catch (...) {
92000       {
92001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92002       };
92003     }
92004   }
92005
92006   jresult = result;
92007
92008   //argout typemap for const std::string&
92009
92010   return jresult;
92011 }
92012
92013
92014 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
92015   unsigned int jresult ;
92016   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92017   std::string *arg2 = 0 ;
92018   Dali::ImageDimensions arg3 ;
92019   Dali::FittingMode::Type arg4 ;
92020   Dali::SamplingMode::Type arg5 ;
92021   bool arg6 ;
92022   Dali::ImageDimensions *argp3 ;
92023   uint32_t result;
92024
92025   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92026   if (!jarg2) {
92027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92028     return 0;
92029   }
92030   std::string arg2_str(jarg2);
92031   arg2 = &arg2_str;
92032   argp3 = (Dali::ImageDimensions *)jarg3;
92033   if (!argp3) {
92034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92035     return 0;
92036   }
92037   arg3 = *argp3;
92038   arg4 = (Dali::FittingMode::Type)jarg4;
92039   arg5 = (Dali::SamplingMode::Type)jarg5;
92040   arg6 = jarg6 ? true : false;
92041   {
92042     try {
92043       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
92044     } catch (std::out_of_range& e) {
92045       {
92046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92047       };
92048     } catch (std::exception& e) {
92049       {
92050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92051       };
92052     } catch (Dali::DaliException e) {
92053       {
92054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92055       };
92056     } catch (...) {
92057       {
92058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92059       };
92060     }
92061   }
92062
92063   jresult = result;
92064
92065   //argout typemap for const std::string&
92066
92067   return jresult;
92068 }
92069
92070
92071 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
92072   unsigned int jresult ;
92073   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92074   uint32_t arg2 ;
92075   bool result;
92076
92077   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92078   arg2 = (uint32_t)jarg2;
92079   {
92080     try {
92081       result = (bool)(arg1)->Cancel(arg2);
92082     } catch (std::out_of_range& e) {
92083       {
92084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92085       };
92086     } catch (std::exception& e) {
92087       {
92088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92089       };
92090     } catch (Dali::DaliException e) {
92091       {
92092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92093       };
92094     } catch (...) {
92095       {
92096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92097       };
92098     }
92099   }
92100
92101   jresult = result;
92102   return jresult;
92103 }
92104
92105
92106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
92107   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92108
92109   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92110   {
92111     try {
92112       (arg1)->CancelAll();
92113     } catch (std::out_of_range& e) {
92114       {
92115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92116       };
92117     } catch (std::exception& e) {
92118       {
92119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92120       };
92121     } catch (Dali::DaliException e) {
92122       {
92123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92124       };
92125     } catch (...) {
92126       {
92127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92128       };
92129     }
92130   }
92131
92132 }
92133
92134
92135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
92136   void * jresult ;
92137   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92138   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
92139
92140   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92141   {
92142     try {
92143       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
92144     } catch (std::out_of_range& e) {
92145       {
92146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92147       };
92148     } catch (std::exception& e) {
92149       {
92150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92151       };
92152     } catch (Dali::DaliException e) {
92153       {
92154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92155       };
92156     } catch (...) {
92157       {
92158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92159       };
92160     }
92161   }
92162
92163   jresult = (void *)result;
92164   return jresult;
92165 }
92166
92167
92168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_2(void * jarg1) {
92169   void * jresult ;
92170   Dali::Toolkit::Internal::AsyncImageLoader *arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *) 0 ;
92171   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92172
92173   arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *)jarg1;
92174   {
92175     try {
92176       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader(arg1);
92177     } catch (std::out_of_range& e) {
92178       {
92179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92180       };
92181     } catch (std::exception& e) {
92182       {
92183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92184       };
92185     } catch (Dali::DaliException e) {
92186       {
92187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92188       };
92189     } catch (...) {
92190       {
92191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92192       };
92193     }
92194   }
92195
92196   jresult = (void *)result;
92197   return jresult;
92198 }
92199
92200
92201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
92202   void * jresult ;
92203   std::string *arg1 = 0 ;
92204   Dali::PixelData result;
92205
92206   if (!jarg1) {
92207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92208     return 0;
92209   }
92210   std::string arg1_str(jarg1);
92211   arg1 = &arg1_str;
92212   {
92213     try {
92214       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
92215     } catch (std::out_of_range& e) {
92216       {
92217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92218       };
92219     } catch (std::exception& e) {
92220       {
92221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92222       };
92223     } catch (Dali::DaliException e) {
92224       {
92225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92226       };
92227     } catch (...) {
92228       {
92229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92230       };
92231     }
92232   }
92233
92234   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92235
92236   //argout typemap for const std::string&
92237
92238   return jresult;
92239 }
92240
92241
92242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
92243   void * jresult ;
92244   std::string *arg1 = 0 ;
92245   Dali::ImageDimensions arg2 ;
92246   Dali::ImageDimensions *argp2 ;
92247   Dali::PixelData result;
92248
92249   if (!jarg1) {
92250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92251     return 0;
92252   }
92253   std::string arg1_str(jarg1);
92254   arg1 = &arg1_str;
92255   argp2 = (Dali::ImageDimensions *)jarg2;
92256   if (!argp2) {
92257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92258     return 0;
92259   }
92260   arg2 = *argp2;
92261   {
92262     try {
92263       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
92264     } catch (std::out_of_range& e) {
92265       {
92266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92267       };
92268     } catch (std::exception& e) {
92269       {
92270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92271       };
92272     } catch (Dali::DaliException e) {
92273       {
92274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92275       };
92276     } catch (...) {
92277       {
92278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92279       };
92280     }
92281   }
92282
92283   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92284
92285   //argout typemap for const std::string&
92286
92287   return jresult;
92288 }
92289
92290
92291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
92292   void * jresult ;
92293   std::string *arg1 = 0 ;
92294   Dali::ImageDimensions arg2 ;
92295   Dali::FittingMode::Type arg3 ;
92296   Dali::SamplingMode::Type arg4 ;
92297   bool arg5 ;
92298   Dali::ImageDimensions *argp2 ;
92299   Dali::PixelData result;
92300
92301   if (!jarg1) {
92302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92303     return 0;
92304   }
92305   std::string arg1_str(jarg1);
92306   arg1 = &arg1_str;
92307   argp2 = (Dali::ImageDimensions *)jarg2;
92308   if (!argp2) {
92309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92310     return 0;
92311   }
92312   arg2 = *argp2;
92313   arg3 = (Dali::FittingMode::Type)jarg3;
92314   arg4 = (Dali::SamplingMode::Type)jarg4;
92315   arg5 = jarg5 ? true : false;
92316   {
92317     try {
92318       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
92319     } catch (std::out_of_range& e) {
92320       {
92321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92322       };
92323     } catch (std::exception& e) {
92324       {
92325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92326       };
92327     } catch (Dali::DaliException e) {
92328       {
92329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92330       };
92331     } catch (...) {
92332       {
92333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92334       };
92335     }
92336   }
92337
92338   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92339
92340   //argout typemap for const std::string&
92341
92342   return jresult;
92343 }
92344
92345
92346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
92347   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92348
92349   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92350   {
92351     try {
92352       delete arg1;
92353     } catch (std::out_of_range& e) {
92354       {
92355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92356       };
92357     } catch (std::exception& e) {
92358       {
92359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92360       };
92361     } catch (Dali::DaliException e) {
92362       {
92363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92364       };
92365     } catch (...) {
92366       {
92367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92368       };
92369     }
92370   }
92371
92372 }
92373
92374
92375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
92376   void * jresult ;
92377   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92378   Dali::Actor arg2 ;
92379   Dali::Actor arg3 ;
92380   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
92381   Dali::Actor *argp2 ;
92382   Dali::Actor *argp3 ;
92383   Dali::Actor result;
92384
92385   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92386   argp2 = (Dali::Actor *)jarg2;
92387   if (!argp2) {
92388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92389     return 0;
92390   }
92391   arg2 = *argp2;
92392   argp3 = (Dali::Actor *)jarg3;
92393   if (!argp3) {
92394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92395     return 0;
92396   }
92397   arg3 = *argp3;
92398   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
92399   {
92400     try {
92401       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
92402     } catch (std::out_of_range& e) {
92403       {
92404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92405       };
92406     } catch (std::exception& e) {
92407       {
92408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92409       };
92410     } catch (Dali::DaliException e) {
92411       {
92412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92413       };
92414     } catch (...) {
92415       {
92416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92417       };
92418     }
92419   }
92420
92421   jresult = new Dali::Actor((const Dali::Actor &)result);
92422   return jresult;
92423 }
92424
92425
92426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
92427   void * jresult ;
92428   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
92429
92430   {
92431     try {
92432       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
92433     } catch (std::out_of_range& e) {
92434       {
92435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92436       };
92437     } catch (std::exception& e) {
92438       {
92439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92440       };
92441     } catch (Dali::DaliException e) {
92442       {
92443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92444       };
92445     } catch (...) {
92446       {
92447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92448       };
92449     }
92450   }
92451
92452   jresult = (void *)result;
92453   return jresult;
92454 }
92455
92456
92457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
92458   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
92459   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
92460   if (director) {
92461     director->swig_connect_director(callback0);
92462   }
92463 }
92464
92465
92466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
92467   KeyboardFocusManager arg1 ;
92468   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
92469   KeyboardFocusManager *argp1 ;
92470
92471   argp1 = (KeyboardFocusManager *)jarg1;
92472   if (!argp1) {
92473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
92474     return ;
92475   }
92476   arg1 = *argp1;
92477   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
92478   if (!arg2) {
92479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
92480     return ;
92481   }
92482   {
92483     try {
92484       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
92485     } catch (std::out_of_range& e) {
92486       {
92487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92488       };
92489     } catch (std::exception& e) {
92490       {
92491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92492       };
92493     } catch (Dali::DaliException e) {
92494       {
92495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92496       };
92497     } catch (...) {
92498       {
92499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92500       };
92501     }
92502   }
92503
92504 }
92505
92506
92507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
92508   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92509
92510   arg1 = (std::vector< unsigned int > *)jarg1;
92511   {
92512     try {
92513       (arg1)->clear();
92514     } catch (std::out_of_range& e) {
92515       {
92516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92517       };
92518     } catch (std::exception& e) {
92519       {
92520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92521       };
92522     } catch (Dali::DaliException e) {
92523       {
92524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92525       };
92526     } catch (...) {
92527       {
92528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92529       };
92530     }
92531   }
92532
92533 }
92534
92535
92536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
92537   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92538   unsigned int *arg2 = 0 ;
92539   unsigned int temp2 ;
92540
92541   arg1 = (std::vector< unsigned int > *)jarg1;
92542   temp2 = (unsigned int)jarg2;
92543   arg2 = &temp2;
92544   {
92545     try {
92546       (arg1)->push_back((unsigned int const &)*arg2);
92547     } catch (std::out_of_range& e) {
92548       {
92549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92550       };
92551     } catch (std::exception& e) {
92552       {
92553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92554       };
92555     } catch (Dali::DaliException e) {
92556       {
92557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92558       };
92559     } catch (...) {
92560       {
92561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92562       };
92563     }
92564   }
92565
92566 }
92567
92568
92569 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
92570   unsigned long jresult ;
92571   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92572   std::vector< unsigned int >::size_type result;
92573
92574   arg1 = (std::vector< unsigned int > *)jarg1;
92575   {
92576     try {
92577       result = ((std::vector< unsigned int > const *)arg1)->size();
92578     } catch (std::out_of_range& e) {
92579       {
92580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92581       };
92582     } catch (std::exception& e) {
92583       {
92584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92585       };
92586     } catch (Dali::DaliException e) {
92587       {
92588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92589       };
92590     } catch (...) {
92591       {
92592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92593       };
92594     }
92595   }
92596
92597   jresult = (unsigned long)result;
92598   return jresult;
92599 }
92600
92601
92602 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
92603   unsigned long jresult ;
92604   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92605   std::vector< unsigned int >::size_type result;
92606
92607   arg1 = (std::vector< unsigned int > *)jarg1;
92608   {
92609     try {
92610       result = ((std::vector< unsigned int > const *)arg1)->capacity();
92611     } catch (std::out_of_range& e) {
92612       {
92613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92614       };
92615     } catch (std::exception& e) {
92616       {
92617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92618       };
92619     } catch (Dali::DaliException e) {
92620       {
92621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92622       };
92623     } catch (...) {
92624       {
92625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92626       };
92627     }
92628   }
92629
92630   jresult = (unsigned long)result;
92631   return jresult;
92632 }
92633
92634
92635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
92636   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92637   std::vector< unsigned int >::size_type arg2 ;
92638
92639   arg1 = (std::vector< unsigned int > *)jarg1;
92640   arg2 = (std::vector< unsigned int >::size_type)jarg2;
92641   {
92642     try {
92643       (arg1)->reserve(arg2);
92644     } catch (std::out_of_range& e) {
92645       {
92646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92647       };
92648     } catch (std::exception& e) {
92649       {
92650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92651       };
92652     } catch (Dali::DaliException e) {
92653       {
92654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92655       };
92656     } catch (...) {
92657       {
92658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92659       };
92660     }
92661   }
92662
92663 }
92664
92665
92666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
92667   void * jresult ;
92668   std::vector< unsigned int > *result = 0 ;
92669
92670   {
92671     try {
92672       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
92673     } catch (std::out_of_range& e) {
92674       {
92675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92676       };
92677     } catch (std::exception& e) {
92678       {
92679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92680       };
92681     } catch (Dali::DaliException e) {
92682       {
92683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92684       };
92685     } catch (...) {
92686       {
92687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92688       };
92689     }
92690   }
92691
92692   jresult = (void *)result;
92693   return jresult;
92694 }
92695
92696
92697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
92698   void * jresult ;
92699   std::vector< unsigned int > *arg1 = 0 ;
92700   std::vector< unsigned int > *result = 0 ;
92701
92702   arg1 = (std::vector< unsigned int > *)jarg1;
92703   if (!arg1) {
92704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92705     return 0;
92706   }
92707   {
92708     try {
92709       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
92710     } catch (std::out_of_range& e) {
92711       {
92712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92713       };
92714     } catch (std::exception& e) {
92715       {
92716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92717       };
92718     } catch (Dali::DaliException e) {
92719       {
92720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92721       };
92722     } catch (...) {
92723       {
92724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92725       };
92726     }
92727   }
92728
92729   jresult = (void *)result;
92730   return jresult;
92731 }
92732
92733
92734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
92735   void * jresult ;
92736   int arg1 ;
92737   std::vector< unsigned int > *result = 0 ;
92738
92739   arg1 = (int)jarg1;
92740   {
92741     try {
92742       try {
92743         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
92744       }
92745       catch(std::out_of_range &_e) {
92746         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92747         return 0;
92748       }
92749
92750     } catch (std::out_of_range& e) {
92751       {
92752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92753       };
92754     } catch (std::exception& e) {
92755       {
92756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92757       };
92758     } catch (Dali::DaliException e) {
92759       {
92760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92761       };
92762     } catch (...) {
92763       {
92764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92765       };
92766     }
92767   }
92768
92769   jresult = (void *)result;
92770   return jresult;
92771 }
92772
92773
92774 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
92775   unsigned int jresult ;
92776   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92777   int arg2 ;
92778   unsigned int result;
92779
92780   arg1 = (std::vector< unsigned int > *)jarg1;
92781   arg2 = (int)jarg2;
92782   {
92783     try {
92784       try {
92785         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
92786       }
92787       catch(std::out_of_range &_e) {
92788         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92789         return 0;
92790       }
92791
92792     } catch (std::out_of_range& e) {
92793       {
92794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92795       };
92796     } catch (std::exception& e) {
92797       {
92798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92799       };
92800     } catch (Dali::DaliException e) {
92801       {
92802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92803       };
92804     } catch (...) {
92805       {
92806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92807       };
92808     }
92809   }
92810
92811   jresult = result;
92812   return jresult;
92813 }
92814
92815
92816 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
92817   unsigned int jresult ;
92818   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92819   int arg2 ;
92820   unsigned int *result = 0 ;
92821
92822   arg1 = (std::vector< unsigned int > *)jarg1;
92823   arg2 = (int)jarg2;
92824   {
92825     try {
92826       try {
92827         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
92828       }
92829       catch(std::out_of_range &_e) {
92830         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92831         return 0;
92832       }
92833
92834     } catch (std::out_of_range& e) {
92835       {
92836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92837       };
92838     } catch (std::exception& e) {
92839       {
92840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92841       };
92842     } catch (Dali::DaliException e) {
92843       {
92844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92845       };
92846     } catch (...) {
92847       {
92848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92849       };
92850     }
92851   }
92852
92853   jresult = *result;
92854   return jresult;
92855 }
92856
92857
92858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
92859   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92860   int arg2 ;
92861   unsigned int *arg3 = 0 ;
92862   unsigned int temp3 ;
92863
92864   arg1 = (std::vector< unsigned int > *)jarg1;
92865   arg2 = (int)jarg2;
92866   temp3 = (unsigned int)jarg3;
92867   arg3 = &temp3;
92868   {
92869     try {
92870       try {
92871         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
92872       }
92873       catch(std::out_of_range &_e) {
92874         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92875         return ;
92876       }
92877
92878     } catch (std::out_of_range& e) {
92879       {
92880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92881       };
92882     } catch (std::exception& e) {
92883       {
92884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92885       };
92886     } catch (Dali::DaliException e) {
92887       {
92888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92889       };
92890     } catch (...) {
92891       {
92892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92893       };
92894     }
92895   }
92896
92897 }
92898
92899
92900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
92901   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92902   std::vector< unsigned int > *arg2 = 0 ;
92903
92904   arg1 = (std::vector< unsigned int > *)jarg1;
92905   arg2 = (std::vector< unsigned int > *)jarg2;
92906   if (!arg2) {
92907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92908     return ;
92909   }
92910   {
92911     try {
92912       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
92913     } catch (std::out_of_range& e) {
92914       {
92915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92916       };
92917     } catch (std::exception& e) {
92918       {
92919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92920       };
92921     } catch (Dali::DaliException e) {
92922       {
92923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92924       };
92925     } catch (...) {
92926       {
92927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92928       };
92929     }
92930   }
92931
92932 }
92933
92934
92935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
92936   void * jresult ;
92937   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92938   int arg2 ;
92939   int arg3 ;
92940   std::vector< unsigned int > *result = 0 ;
92941
92942   arg1 = (std::vector< unsigned int > *)jarg1;
92943   arg2 = (int)jarg2;
92944   arg3 = (int)jarg3;
92945   {
92946     try {
92947       try {
92948         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
92949       }
92950       catch(std::out_of_range &_e) {
92951         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92952         return 0;
92953       }
92954       catch(std::invalid_argument &_e) {
92955         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92956         return 0;
92957       }
92958
92959     } catch (std::out_of_range& e) {
92960       {
92961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92962       };
92963     } catch (std::exception& e) {
92964       {
92965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92966       };
92967     } catch (Dali::DaliException e) {
92968       {
92969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92970       };
92971     } catch (...) {
92972       {
92973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92974       };
92975     }
92976   }
92977
92978   jresult = (void *)result;
92979   return jresult;
92980 }
92981
92982
92983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
92984   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92985   int arg2 ;
92986   unsigned int *arg3 = 0 ;
92987   unsigned int temp3 ;
92988
92989   arg1 = (std::vector< unsigned int > *)jarg1;
92990   arg2 = (int)jarg2;
92991   temp3 = (unsigned int)jarg3;
92992   arg3 = &temp3;
92993   {
92994     try {
92995       try {
92996         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
92997       }
92998       catch(std::out_of_range &_e) {
92999         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93000         return ;
93001       }
93002
93003     } catch (std::out_of_range& e) {
93004       {
93005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93006       };
93007     } catch (std::exception& e) {
93008       {
93009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93010       };
93011     } catch (Dali::DaliException e) {
93012       {
93013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93014       };
93015     } catch (...) {
93016       {
93017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93018       };
93019     }
93020   }
93021
93022 }
93023
93024
93025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
93026   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93027   int arg2 ;
93028   std::vector< unsigned int > *arg3 = 0 ;
93029
93030   arg1 = (std::vector< unsigned int > *)jarg1;
93031   arg2 = (int)jarg2;
93032   arg3 = (std::vector< unsigned int > *)jarg3;
93033   if (!arg3) {
93034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93035     return ;
93036   }
93037   {
93038     try {
93039       try {
93040         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
93041       }
93042       catch(std::out_of_range &_e) {
93043         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93044         return ;
93045       }
93046
93047     } catch (std::out_of_range& e) {
93048       {
93049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93050       };
93051     } catch (std::exception& e) {
93052       {
93053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93054       };
93055     } catch (Dali::DaliException e) {
93056       {
93057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93058       };
93059     } catch (...) {
93060       {
93061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93062       };
93063     }
93064   }
93065
93066 }
93067
93068
93069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
93070   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93071   int arg2 ;
93072
93073   arg1 = (std::vector< unsigned int > *)jarg1;
93074   arg2 = (int)jarg2;
93075   {
93076     try {
93077       try {
93078         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
93079       }
93080       catch(std::out_of_range &_e) {
93081         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93082         return ;
93083       }
93084
93085     } catch (std::out_of_range& e) {
93086       {
93087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93088       };
93089     } catch (std::exception& e) {
93090       {
93091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93092       };
93093     } catch (Dali::DaliException e) {
93094       {
93095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93096       };
93097     } catch (...) {
93098       {
93099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93100       };
93101     }
93102   }
93103
93104 }
93105
93106
93107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
93108   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93109   int arg2 ;
93110   int arg3 ;
93111
93112   arg1 = (std::vector< unsigned int > *)jarg1;
93113   arg2 = (int)jarg2;
93114   arg3 = (int)jarg3;
93115   {
93116     try {
93117       try {
93118         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
93119       }
93120       catch(std::out_of_range &_e) {
93121         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93122         return ;
93123       }
93124       catch(std::invalid_argument &_e) {
93125         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93126         return ;
93127       }
93128
93129     } catch (std::out_of_range& e) {
93130       {
93131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93132       };
93133     } catch (std::exception& e) {
93134       {
93135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93136       };
93137     } catch (Dali::DaliException e) {
93138       {
93139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93140       };
93141     } catch (...) {
93142       {
93143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93144       };
93145     }
93146   }
93147
93148 }
93149
93150
93151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
93152   void * jresult ;
93153   unsigned int *arg1 = 0 ;
93154   int arg2 ;
93155   unsigned int temp1 ;
93156   std::vector< unsigned int > *result = 0 ;
93157
93158   temp1 = (unsigned int)jarg1;
93159   arg1 = &temp1;
93160   arg2 = (int)jarg2;
93161   {
93162     try {
93163       try {
93164         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
93165       }
93166       catch(std::out_of_range &_e) {
93167         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93168         return 0;
93169       }
93170
93171     } catch (std::out_of_range& e) {
93172       {
93173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93174       };
93175     } catch (std::exception& e) {
93176       {
93177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93178       };
93179     } catch (Dali::DaliException e) {
93180       {
93181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93182       };
93183     } catch (...) {
93184       {
93185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93186       };
93187     }
93188   }
93189
93190   jresult = (void *)result;
93191   return jresult;
93192 }
93193
93194
93195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
93196   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93197
93198   arg1 = (std::vector< unsigned int > *)jarg1;
93199   {
93200     try {
93201       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
93202     } catch (std::out_of_range& e) {
93203       {
93204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93205       };
93206     } catch (std::exception& e) {
93207       {
93208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93209       };
93210     } catch (Dali::DaliException e) {
93211       {
93212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93213       };
93214     } catch (...) {
93215       {
93216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93217       };
93218     }
93219   }
93220
93221 }
93222
93223
93224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
93225   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93226   int arg2 ;
93227   int arg3 ;
93228
93229   arg1 = (std::vector< unsigned int > *)jarg1;
93230   arg2 = (int)jarg2;
93231   arg3 = (int)jarg3;
93232   {
93233     try {
93234       try {
93235         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
93236       }
93237       catch(std::out_of_range &_e) {
93238         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93239         return ;
93240       }
93241       catch(std::invalid_argument &_e) {
93242         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93243         return ;
93244       }
93245
93246     } catch (std::out_of_range& e) {
93247       {
93248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93249       };
93250     } catch (std::exception& e) {
93251       {
93252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93253       };
93254     } catch (Dali::DaliException e) {
93255       {
93256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93257       };
93258     } catch (...) {
93259       {
93260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93261       };
93262     }
93263   }
93264
93265 }
93266
93267
93268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
93269   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93270   int arg2 ;
93271   std::vector< unsigned int > *arg3 = 0 ;
93272
93273   arg1 = (std::vector< unsigned int > *)jarg1;
93274   arg2 = (int)jarg2;
93275   arg3 = (std::vector< unsigned int > *)jarg3;
93276   if (!arg3) {
93277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93278     return ;
93279   }
93280   {
93281     try {
93282       try {
93283         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
93284       }
93285       catch(std::out_of_range &_e) {
93286         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93287         return ;
93288       }
93289
93290     } catch (std::out_of_range& e) {
93291       {
93292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93293       };
93294     } catch (std::exception& e) {
93295       {
93296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93297       };
93298     } catch (Dali::DaliException e) {
93299       {
93300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93301       };
93302     } catch (...) {
93303       {
93304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93305       };
93306     }
93307   }
93308
93309 }
93310
93311
93312 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
93313   unsigned int jresult ;
93314   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93315   unsigned int *arg2 = 0 ;
93316   unsigned int temp2 ;
93317   bool result;
93318
93319   arg1 = (std::vector< unsigned int > *)jarg1;
93320   temp2 = (unsigned int)jarg2;
93321   arg2 = &temp2;
93322   {
93323     try {
93324       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
93325     } catch (std::out_of_range& e) {
93326       {
93327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93328       };
93329     } catch (std::exception& e) {
93330       {
93331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93332       };
93333     } catch (Dali::DaliException e) {
93334       {
93335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93336       };
93337     } catch (...) {
93338       {
93339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93340       };
93341     }
93342   }
93343
93344   jresult = result;
93345   return jresult;
93346 }
93347
93348
93349 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
93350   int jresult ;
93351   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93352   unsigned int *arg2 = 0 ;
93353   unsigned int temp2 ;
93354   int result;
93355
93356   arg1 = (std::vector< unsigned int > *)jarg1;
93357   temp2 = (unsigned int)jarg2;
93358   arg2 = &temp2;
93359   {
93360     try {
93361       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
93362     } catch (std::out_of_range& e) {
93363       {
93364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93365       };
93366     } catch (std::exception& e) {
93367       {
93368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93369       };
93370     } catch (Dali::DaliException e) {
93371       {
93372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93373       };
93374     } catch (...) {
93375       {
93376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93377       };
93378     }
93379   }
93380
93381   jresult = result;
93382   return jresult;
93383 }
93384
93385
93386 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
93387   int jresult ;
93388   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93389   unsigned int *arg2 = 0 ;
93390   unsigned int temp2 ;
93391   int result;
93392
93393   arg1 = (std::vector< unsigned int > *)jarg1;
93394   temp2 = (unsigned int)jarg2;
93395   arg2 = &temp2;
93396   {
93397     try {
93398       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
93399     } catch (std::out_of_range& e) {
93400       {
93401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93402       };
93403     } catch (std::exception& e) {
93404       {
93405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93406       };
93407     } catch (Dali::DaliException e) {
93408       {
93409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93410       };
93411     } catch (...) {
93412       {
93413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93414       };
93415     }
93416   }
93417
93418   jresult = result;
93419   return jresult;
93420 }
93421
93422
93423 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
93424   unsigned int jresult ;
93425   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93426   unsigned int *arg2 = 0 ;
93427   unsigned int temp2 ;
93428   bool result;
93429
93430   arg1 = (std::vector< unsigned int > *)jarg1;
93431   temp2 = (unsigned int)jarg2;
93432   arg2 = &temp2;
93433   {
93434     try {
93435       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
93436     } catch (std::out_of_range& e) {
93437       {
93438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93439       };
93440     } catch (std::exception& e) {
93441       {
93442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93443       };
93444     } catch (Dali::DaliException e) {
93445       {
93446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93447       };
93448     } catch (...) {
93449       {
93450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93451       };
93452     }
93453   }
93454
93455   jresult = result;
93456   return jresult;
93457 }
93458
93459
93460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
93461   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93462
93463   arg1 = (std::vector< unsigned int > *)jarg1;
93464   {
93465     try {
93466       delete arg1;
93467     } catch (std::out_of_range& e) {
93468       {
93469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93470       };
93471     } catch (std::exception& e) {
93472       {
93473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93474       };
93475     } catch (Dali::DaliException e) {
93476       {
93477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93478       };
93479     } catch (...) {
93480       {
93481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93482       };
93483     }
93484   }
93485
93486 }
93487
93488
93489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
93490   void * jresult ;
93491   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93492
93493   {
93494     try {
93495       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
93496     } catch (std::out_of_range& e) {
93497       {
93498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93499       };
93500     } catch (std::exception& e) {
93501       {
93502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93503       };
93504     } catch (Dali::DaliException e) {
93505       {
93506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93507       };
93508     } catch (...) {
93509       {
93510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93511       };
93512     }
93513   }
93514
93515   jresult = (void *)result;
93516   return jresult;
93517 }
93518
93519
93520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
93521   void * jresult ;
93522   unsigned int arg1 ;
93523   Dali::Actor arg2 ;
93524   Dali::Actor *argp2 ;
93525   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93526
93527   arg1 = (unsigned int)jarg1;
93528   argp2 = (Dali::Actor *)jarg2;
93529   if (!argp2) {
93530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
93531     return 0;
93532   }
93533   arg2 = *argp2;
93534   {
93535     try {
93536       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
93537     } catch (std::out_of_range& e) {
93538       {
93539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93540       };
93541     } catch (std::exception& e) {
93542       {
93543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93544       };
93545     } catch (Dali::DaliException e) {
93546       {
93547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93548       };
93549     } catch (...) {
93550       {
93551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93552       };
93553     }
93554   }
93555
93556   jresult = (void *)result;
93557   return jresult;
93558 }
93559
93560
93561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
93562   void * jresult ;
93563   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
93564   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93565
93566   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93567   if (!arg1) {
93568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93569     return 0;
93570   }
93571   {
93572     try {
93573       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
93574     } catch (std::out_of_range& e) {
93575       {
93576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93577       };
93578     } catch (std::exception& e) {
93579       {
93580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93581       };
93582     } catch (Dali::DaliException e) {
93583       {
93584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93585       };
93586     } catch (...) {
93587       {
93588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93589       };
93590     }
93591   }
93592
93593   jresult = (void *)result;
93594   return jresult;
93595 }
93596
93597
93598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
93599   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93600   unsigned int arg2 ;
93601
93602   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93603   arg2 = (unsigned int)jarg2;
93604   if (arg1) (arg1)->first = arg2;
93605 }
93606
93607
93608 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
93609   unsigned int jresult ;
93610   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93611   unsigned int result;
93612
93613   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93614   result = (unsigned int) ((arg1)->first);
93615   jresult = result;
93616   return jresult;
93617 }
93618
93619
93620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
93621   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93622   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
93623
93624   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93625   arg2 = (Dali::Actor *)jarg2;
93626   if (arg1) (arg1)->second = *arg2;
93627 }
93628
93629
93630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
93631   void * jresult ;
93632   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93633   Dali::Actor *result = 0 ;
93634
93635   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93636   result = (Dali::Actor *)& ((arg1)->second);
93637   jresult = (void *)result;
93638   return jresult;
93639 }
93640
93641
93642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
93643   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93644
93645   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93646   {
93647     try {
93648       delete arg1;
93649     } catch (std::out_of_range& e) {
93650       {
93651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93652       };
93653     } catch (std::exception& e) {
93654       {
93655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93656       };
93657     } catch (Dali::DaliException e) {
93658       {
93659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93660       };
93661     } catch (...) {
93662       {
93663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93664       };
93665     }
93666   }
93667
93668 }
93669
93670
93671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
93672   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93673
93674   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93675   {
93676     try {
93677       (arg1)->clear();
93678     } catch (std::out_of_range& e) {
93679       {
93680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93681       };
93682     } catch (std::exception& e) {
93683       {
93684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93685       };
93686     } catch (Dali::DaliException e) {
93687       {
93688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93689       };
93690     } catch (...) {
93691       {
93692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93693       };
93694     }
93695   }
93696
93697 }
93698
93699
93700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
93701   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93702   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
93703
93704   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93705   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
93706   if (!arg2) {
93707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93708     return ;
93709   }
93710   {
93711     try {
93712       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
93713     } catch (std::out_of_range& e) {
93714       {
93715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93716       };
93717     } catch (std::exception& e) {
93718       {
93719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93720       };
93721     } catch (Dali::DaliException e) {
93722       {
93723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93724       };
93725     } catch (...) {
93726       {
93727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93728       };
93729     }
93730   }
93731
93732 }
93733
93734
93735 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
93736   unsigned long jresult ;
93737   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93738   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
93739
93740   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93741   {
93742     try {
93743       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
93744     } catch (std::out_of_range& e) {
93745       {
93746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93747       };
93748     } catch (std::exception& e) {
93749       {
93750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93751       };
93752     } catch (Dali::DaliException e) {
93753       {
93754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93755       };
93756     } catch (...) {
93757       {
93758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93759       };
93760     }
93761   }
93762
93763   jresult = (unsigned long)result;
93764   return jresult;
93765 }
93766
93767
93768 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
93769   unsigned long jresult ;
93770   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93771   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
93772
93773   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93774   {
93775     try {
93776       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
93777     } catch (std::out_of_range& e) {
93778       {
93779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93780       };
93781     } catch (std::exception& e) {
93782       {
93783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93784       };
93785     } catch (Dali::DaliException e) {
93786       {
93787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93788       };
93789     } catch (...) {
93790       {
93791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93792       };
93793     }
93794   }
93795
93796   jresult = (unsigned long)result;
93797   return jresult;
93798 }
93799
93800
93801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
93802   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93803   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
93804
93805   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93806   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
93807   {
93808     try {
93809       (arg1)->reserve(arg2);
93810     } catch (std::out_of_range& e) {
93811       {
93812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93813       };
93814     } catch (std::exception& e) {
93815       {
93816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93817       };
93818     } catch (Dali::DaliException e) {
93819       {
93820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93821       };
93822     } catch (...) {
93823       {
93824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93825       };
93826     }
93827   }
93828
93829 }
93830
93831
93832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
93833   void * jresult ;
93834   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93835
93836   {
93837     try {
93838       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
93839     } catch (std::out_of_range& e) {
93840       {
93841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93842       };
93843     } catch (std::exception& e) {
93844       {
93845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93846       };
93847     } catch (Dali::DaliException e) {
93848       {
93849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93850       };
93851     } catch (...) {
93852       {
93853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93854       };
93855     }
93856   }
93857
93858   jresult = (void *)result;
93859   return jresult;
93860 }
93861
93862
93863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
93864   void * jresult ;
93865   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
93866   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93867
93868   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93869   if (!arg1) {
93870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93871     return 0;
93872   }
93873   {
93874     try {
93875       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);
93876     } catch (std::out_of_range& e) {
93877       {
93878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93879       };
93880     } catch (std::exception& e) {
93881       {
93882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93883       };
93884     } catch (Dali::DaliException e) {
93885       {
93886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93887       };
93888     } catch (...) {
93889       {
93890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93891       };
93892     }
93893   }
93894
93895   jresult = (void *)result;
93896   return jresult;
93897 }
93898
93899
93900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
93901   void * jresult ;
93902   int arg1 ;
93903   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93904
93905   arg1 = (int)jarg1;
93906   {
93907     try {
93908       try {
93909         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);
93910       }
93911       catch(std::out_of_range &_e) {
93912         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93913         return 0;
93914       }
93915
93916     } catch (std::out_of_range& e) {
93917       {
93918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93919       };
93920     } catch (std::exception& e) {
93921       {
93922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93923       };
93924     } catch (Dali::DaliException e) {
93925       {
93926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93927       };
93928     } catch (...) {
93929       {
93930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93931       };
93932     }
93933   }
93934
93935   jresult = (void *)result;
93936   return jresult;
93937 }
93938
93939
93940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
93941   void * jresult ;
93942   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93943   int arg2 ;
93944   std::pair< unsigned int,Dali::Actor > result;
93945
93946   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93947   arg2 = (int)jarg2;
93948   {
93949     try {
93950       try {
93951         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
93952       }
93953       catch(std::out_of_range &_e) {
93954         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93955         return 0;
93956       }
93957
93958     } catch (std::out_of_range& e) {
93959       {
93960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93961       };
93962     } catch (std::exception& e) {
93963       {
93964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93965       };
93966     } catch (Dali::DaliException e) {
93967       {
93968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93969       };
93970     } catch (...) {
93971       {
93972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93973       };
93974     }
93975   }
93976
93977   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
93978   return jresult;
93979 }
93980
93981
93982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
93983   void * jresult ;
93984   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93985   int arg2 ;
93986   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93987
93988   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93989   arg2 = (int)jarg2;
93990   {
93991     try {
93992       try {
93993         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
93994       }
93995       catch(std::out_of_range &_e) {
93996         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93997         return 0;
93998       }
93999
94000     } catch (std::out_of_range& e) {
94001       {
94002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94003       };
94004     } catch (std::exception& e) {
94005       {
94006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94007       };
94008     } catch (Dali::DaliException e) {
94009       {
94010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94011       };
94012     } catch (...) {
94013       {
94014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94015       };
94016     }
94017   }
94018
94019   jresult = (void *)result;
94020   return jresult;
94021 }
94022
94023
94024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
94025   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94026   int arg2 ;
94027   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
94028
94029   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94030   arg2 = (int)jarg2;
94031   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
94032   if (!arg3) {
94033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94034     return ;
94035   }
94036   {
94037     try {
94038       try {
94039         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);
94040       }
94041       catch(std::out_of_range &_e) {
94042         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94043         return ;
94044       }
94045
94046     } catch (std::out_of_range& e) {
94047       {
94048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94049       };
94050     } catch (std::exception& e) {
94051       {
94052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94053       };
94054     } catch (Dali::DaliException e) {
94055       {
94056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94057       };
94058     } catch (...) {
94059       {
94060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94061       };
94062     }
94063   }
94064
94065 }
94066
94067
94068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
94069   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94070   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
94071
94072   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94073   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
94074   if (!arg2) {
94075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94076     return ;
94077   }
94078   {
94079     try {
94080       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);
94081     } catch (std::out_of_range& e) {
94082       {
94083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94084       };
94085     } catch (std::exception& e) {
94086       {
94087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94088       };
94089     } catch (Dali::DaliException e) {
94090       {
94091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94092       };
94093     } catch (...) {
94094       {
94095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94096       };
94097     }
94098   }
94099
94100 }
94101
94102
94103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
94104   void * jresult ;
94105   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94106   int arg2 ;
94107   int arg3 ;
94108   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94109
94110   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94111   arg2 = (int)jarg2;
94112   arg3 = (int)jarg3;
94113   {
94114     try {
94115       try {
94116         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);
94117       }
94118       catch(std::out_of_range &_e) {
94119         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94120         return 0;
94121       }
94122       catch(std::invalid_argument &_e) {
94123         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94124         return 0;
94125       }
94126
94127     } catch (std::out_of_range& e) {
94128       {
94129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94130       };
94131     } catch (std::exception& e) {
94132       {
94133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94134       };
94135     } catch (Dali::DaliException e) {
94136       {
94137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94138       };
94139     } catch (...) {
94140       {
94141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94142       };
94143     }
94144   }
94145
94146   jresult = (void *)result;
94147   return jresult;
94148 }
94149
94150
94151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
94152   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94153   int arg2 ;
94154   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
94155
94156   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94157   arg2 = (int)jarg2;
94158   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
94159   if (!arg3) {
94160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94161     return ;
94162   }
94163   {
94164     try {
94165       try {
94166         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);
94167       }
94168       catch(std::out_of_range &_e) {
94169         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94170         return ;
94171       }
94172
94173     } catch (std::out_of_range& e) {
94174       {
94175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94176       };
94177     } catch (std::exception& e) {
94178       {
94179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94180       };
94181     } catch (Dali::DaliException e) {
94182       {
94183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94184       };
94185     } catch (...) {
94186       {
94187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94188       };
94189     }
94190   }
94191
94192 }
94193
94194
94195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
94196   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94197   int arg2 ;
94198   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94199
94200   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94201   arg2 = (int)jarg2;
94202   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94203   if (!arg3) {
94204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94205     return ;
94206   }
94207   {
94208     try {
94209       try {
94210         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);
94211       }
94212       catch(std::out_of_range &_e) {
94213         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94214         return ;
94215       }
94216
94217     } catch (std::out_of_range& e) {
94218       {
94219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94220       };
94221     } catch (std::exception& e) {
94222       {
94223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94224       };
94225     } catch (Dali::DaliException e) {
94226       {
94227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94228       };
94229     } catch (...) {
94230       {
94231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94232       };
94233     }
94234   }
94235
94236 }
94237
94238
94239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
94240   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94241   int arg2 ;
94242
94243   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94244   arg2 = (int)jarg2;
94245   {
94246     try {
94247       try {
94248         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
94249       }
94250       catch(std::out_of_range &_e) {
94251         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94252         return ;
94253       }
94254
94255     } catch (std::out_of_range& e) {
94256       {
94257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94258       };
94259     } catch (std::exception& e) {
94260       {
94261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94262       };
94263     } catch (Dali::DaliException e) {
94264       {
94265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94266       };
94267     } catch (...) {
94268       {
94269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94270       };
94271     }
94272   }
94273
94274 }
94275
94276
94277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
94278   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94279   int arg2 ;
94280   int arg3 ;
94281
94282   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94283   arg2 = (int)jarg2;
94284   arg3 = (int)jarg3;
94285   {
94286     try {
94287       try {
94288         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
94289       }
94290       catch(std::out_of_range &_e) {
94291         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94292         return ;
94293       }
94294       catch(std::invalid_argument &_e) {
94295         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94296         return ;
94297       }
94298
94299     } catch (std::out_of_range& e) {
94300       {
94301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94302       };
94303     } catch (std::exception& e) {
94304       {
94305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94306       };
94307     } catch (Dali::DaliException e) {
94308       {
94309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94310       };
94311     } catch (...) {
94312       {
94313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94314       };
94315     }
94316   }
94317
94318 }
94319
94320
94321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
94322   void * jresult ;
94323   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
94324   int arg2 ;
94325   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94326
94327   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94328   if (!arg1) {
94329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94330     return 0;
94331   }
94332   arg2 = (int)jarg2;
94333   {
94334     try {
94335       try {
94336         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);
94337       }
94338       catch(std::out_of_range &_e) {
94339         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94340         return 0;
94341       }
94342
94343     } catch (std::out_of_range& e) {
94344       {
94345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94346       };
94347     } catch (std::exception& e) {
94348       {
94349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94350       };
94351     } catch (Dali::DaliException e) {
94352       {
94353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94354       };
94355     } catch (...) {
94356       {
94357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94358       };
94359     }
94360   }
94361
94362   jresult = (void *)result;
94363   return jresult;
94364 }
94365
94366
94367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
94368   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94369
94370   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94371   {
94372     try {
94373       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
94374     } catch (std::out_of_range& e) {
94375       {
94376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94377       };
94378     } catch (std::exception& e) {
94379       {
94380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94381       };
94382     } catch (Dali::DaliException e) {
94383       {
94384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94385       };
94386     } catch (...) {
94387       {
94388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94389       };
94390     }
94391   }
94392
94393 }
94394
94395
94396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
94397   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94398   int arg2 ;
94399   int arg3 ;
94400
94401   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94402   arg2 = (int)jarg2;
94403   arg3 = (int)jarg3;
94404   {
94405     try {
94406       try {
94407         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
94408       }
94409       catch(std::out_of_range &_e) {
94410         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94411         return ;
94412       }
94413       catch(std::invalid_argument &_e) {
94414         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94415         return ;
94416       }
94417
94418     } catch (std::out_of_range& e) {
94419       {
94420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94421       };
94422     } catch (std::exception& e) {
94423       {
94424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94425       };
94426     } catch (Dali::DaliException e) {
94427       {
94428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94429       };
94430     } catch (...) {
94431       {
94432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94433       };
94434     }
94435   }
94436
94437 }
94438
94439
94440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
94441   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94442   int arg2 ;
94443   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94444
94445   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94446   arg2 = (int)jarg2;
94447   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94448   if (!arg3) {
94449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94450     return ;
94451   }
94452   {
94453     try {
94454       try {
94455         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);
94456       }
94457       catch(std::out_of_range &_e) {
94458         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94459         return ;
94460       }
94461
94462     } catch (std::out_of_range& e) {
94463       {
94464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94465       };
94466     } catch (std::exception& e) {
94467       {
94468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94469       };
94470     } catch (Dali::DaliException e) {
94471       {
94472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94473       };
94474     } catch (...) {
94475       {
94476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94477       };
94478     }
94479   }
94480
94481 }
94482
94483
94484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
94485   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94486
94487   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94488   {
94489     try {
94490       delete arg1;
94491     } catch (std::out_of_range& e) {
94492       {
94493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94494       };
94495     } catch (std::exception& e) {
94496       {
94497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94498       };
94499     } catch (Dali::DaliException e) {
94500       {
94501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94502       };
94503     } catch (...) {
94504       {
94505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94506       };
94507     }
94508   }
94509
94510 }
94511
94512
94513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
94514   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94515
94516   arg1 = (std::vector< Dali::Actor > *)jarg1;
94517   {
94518     try {
94519       (arg1)->clear();
94520     } catch (std::out_of_range& e) {
94521       {
94522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94523       };
94524     } catch (std::exception& e) {
94525       {
94526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94527       };
94528     } catch (Dali::DaliException e) {
94529       {
94530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94531       };
94532     } catch (...) {
94533       {
94534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94535       };
94536     }
94537   }
94538
94539 }
94540
94541
94542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
94543   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94544   Dali::Actor *arg2 = 0 ;
94545
94546   arg1 = (std::vector< Dali::Actor > *)jarg1;
94547   arg2 = (Dali::Actor *)jarg2;
94548   if (!arg2) {
94549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94550     return ;
94551   }
94552   {
94553     try {
94554       (arg1)->push_back((Dali::Actor const &)*arg2);
94555     } catch (std::out_of_range& e) {
94556       {
94557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94558       };
94559     } catch (std::exception& e) {
94560       {
94561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94562       };
94563     } catch (Dali::DaliException e) {
94564       {
94565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94566       };
94567     } catch (...) {
94568       {
94569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94570       };
94571     }
94572   }
94573
94574 }
94575
94576
94577 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
94578   unsigned long jresult ;
94579   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94580   std::vector< Dali::Actor >::size_type result;
94581
94582   arg1 = (std::vector< Dali::Actor > *)jarg1;
94583   {
94584     try {
94585       result = ((std::vector< Dali::Actor > const *)arg1)->size();
94586     } catch (std::out_of_range& e) {
94587       {
94588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94589       };
94590     } catch (std::exception& e) {
94591       {
94592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94593       };
94594     } catch (Dali::DaliException e) {
94595       {
94596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94597       };
94598     } catch (...) {
94599       {
94600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94601       };
94602     }
94603   }
94604
94605   jresult = (unsigned long)result;
94606   return jresult;
94607 }
94608
94609
94610 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
94611   unsigned long jresult ;
94612   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94613   std::vector< Dali::Actor >::size_type result;
94614
94615   arg1 = (std::vector< Dali::Actor > *)jarg1;
94616   {
94617     try {
94618       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
94619     } catch (std::out_of_range& e) {
94620       {
94621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94622       };
94623     } catch (std::exception& e) {
94624       {
94625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94626       };
94627     } catch (Dali::DaliException e) {
94628       {
94629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94630       };
94631     } catch (...) {
94632       {
94633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94634       };
94635     }
94636   }
94637
94638   jresult = (unsigned long)result;
94639   return jresult;
94640 }
94641
94642
94643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
94644   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94645   std::vector< Dali::Actor >::size_type arg2 ;
94646
94647   arg1 = (std::vector< Dali::Actor > *)jarg1;
94648   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
94649   {
94650     try {
94651       (arg1)->reserve(arg2);
94652     } catch (std::out_of_range& e) {
94653       {
94654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94655       };
94656     } catch (std::exception& e) {
94657       {
94658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94659       };
94660     } catch (Dali::DaliException e) {
94661       {
94662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94663       };
94664     } catch (...) {
94665       {
94666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94667       };
94668     }
94669   }
94670
94671 }
94672
94673
94674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
94675   void * jresult ;
94676   std::vector< Dali::Actor > *result = 0 ;
94677
94678   {
94679     try {
94680       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
94681     } catch (std::out_of_range& e) {
94682       {
94683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94684       };
94685     } catch (std::exception& e) {
94686       {
94687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94688       };
94689     } catch (Dali::DaliException e) {
94690       {
94691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94692       };
94693     } catch (...) {
94694       {
94695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94696       };
94697     }
94698   }
94699
94700   jresult = (void *)result;
94701   return jresult;
94702 }
94703
94704
94705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
94706   void * jresult ;
94707   std::vector< Dali::Actor > *arg1 = 0 ;
94708   std::vector< Dali::Actor > *result = 0 ;
94709
94710   arg1 = (std::vector< Dali::Actor > *)jarg1;
94711   if (!arg1) {
94712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94713     return 0;
94714   }
94715   {
94716     try {
94717       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
94718     } catch (std::out_of_range& e) {
94719       {
94720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94721       };
94722     } catch (std::exception& e) {
94723       {
94724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94725       };
94726     } catch (Dali::DaliException e) {
94727       {
94728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94729       };
94730     } catch (...) {
94731       {
94732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94733       };
94734     }
94735   }
94736
94737   jresult = (void *)result;
94738   return jresult;
94739 }
94740
94741
94742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
94743   void * jresult ;
94744   int arg1 ;
94745   std::vector< Dali::Actor > *result = 0 ;
94746
94747   arg1 = (int)jarg1;
94748   {
94749     try {
94750       try {
94751         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
94752       }
94753       catch(std::out_of_range &_e) {
94754         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94755         return 0;
94756       }
94757
94758     } catch (std::out_of_range& e) {
94759       {
94760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94761       };
94762     } catch (std::exception& e) {
94763       {
94764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94765       };
94766     } catch (Dali::DaliException e) {
94767       {
94768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94769       };
94770     } catch (...) {
94771       {
94772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94773       };
94774     }
94775   }
94776
94777   jresult = (void *)result;
94778   return jresult;
94779 }
94780
94781
94782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
94783   void * jresult ;
94784   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94785   int arg2 ;
94786   Dali::Actor result;
94787
94788   arg1 = (std::vector< Dali::Actor > *)jarg1;
94789   arg2 = (int)jarg2;
94790   {
94791     try {
94792       try {
94793         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
94794       }
94795       catch(std::out_of_range &_e) {
94796         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94797         return 0;
94798       }
94799
94800     } catch (std::out_of_range& e) {
94801       {
94802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94803       };
94804     } catch (std::exception& e) {
94805       {
94806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94807       };
94808     } catch (Dali::DaliException e) {
94809       {
94810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94811       };
94812     } catch (...) {
94813       {
94814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94815       };
94816     }
94817   }
94818
94819   jresult = new Dali::Actor((const Dali::Actor &)result);
94820   return jresult;
94821 }
94822
94823
94824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
94825   void * jresult ;
94826   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94827   int arg2 ;
94828   Dali::Actor *result = 0 ;
94829
94830   arg1 = (std::vector< Dali::Actor > *)jarg1;
94831   arg2 = (int)jarg2;
94832   {
94833     try {
94834       try {
94835         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
94836       }
94837       catch(std::out_of_range &_e) {
94838         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94839         return 0;
94840       }
94841
94842     } catch (std::out_of_range& e) {
94843       {
94844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94845       };
94846     } catch (std::exception& e) {
94847       {
94848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94849       };
94850     } catch (Dali::DaliException e) {
94851       {
94852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94853       };
94854     } catch (...) {
94855       {
94856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94857       };
94858     }
94859   }
94860
94861   jresult = (void *)result;
94862   return jresult;
94863 }
94864
94865
94866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
94867   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94868   int arg2 ;
94869   Dali::Actor *arg3 = 0 ;
94870
94871   arg1 = (std::vector< Dali::Actor > *)jarg1;
94872   arg2 = (int)jarg2;
94873   arg3 = (Dali::Actor *)jarg3;
94874   if (!arg3) {
94875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94876     return ;
94877   }
94878   {
94879     try {
94880       try {
94881         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
94882       }
94883       catch(std::out_of_range &_e) {
94884         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94885         return ;
94886       }
94887
94888     } catch (std::out_of_range& e) {
94889       {
94890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94891       };
94892     } catch (std::exception& e) {
94893       {
94894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94895       };
94896     } catch (Dali::DaliException e) {
94897       {
94898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94899       };
94900     } catch (...) {
94901       {
94902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94903       };
94904     }
94905   }
94906
94907 }
94908
94909
94910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
94911   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94912   std::vector< Dali::Actor > *arg2 = 0 ;
94913
94914   arg1 = (std::vector< Dali::Actor > *)jarg1;
94915   arg2 = (std::vector< Dali::Actor > *)jarg2;
94916   if (!arg2) {
94917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94918     return ;
94919   }
94920   {
94921     try {
94922       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
94923     } catch (std::out_of_range& e) {
94924       {
94925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94926       };
94927     } catch (std::exception& e) {
94928       {
94929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94930       };
94931     } catch (Dali::DaliException e) {
94932       {
94933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94934       };
94935     } catch (...) {
94936       {
94937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94938       };
94939     }
94940   }
94941
94942 }
94943
94944
94945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
94946   void * jresult ;
94947   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94948   int arg2 ;
94949   int arg3 ;
94950   std::vector< Dali::Actor > *result = 0 ;
94951
94952   arg1 = (std::vector< Dali::Actor > *)jarg1;
94953   arg2 = (int)jarg2;
94954   arg3 = (int)jarg3;
94955   {
94956     try {
94957       try {
94958         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
94959       }
94960       catch(std::out_of_range &_e) {
94961         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94962         return 0;
94963       }
94964       catch(std::invalid_argument &_e) {
94965         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94966         return 0;
94967       }
94968
94969     } catch (std::out_of_range& e) {
94970       {
94971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94972       };
94973     } catch (std::exception& e) {
94974       {
94975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94976       };
94977     } catch (Dali::DaliException e) {
94978       {
94979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94980       };
94981     } catch (...) {
94982       {
94983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94984       };
94985     }
94986   }
94987
94988   jresult = (void *)result;
94989   return jresult;
94990 }
94991
94992
94993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
94994   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94995   int arg2 ;
94996   Dali::Actor *arg3 = 0 ;
94997
94998   arg1 = (std::vector< Dali::Actor > *)jarg1;
94999   arg2 = (int)jarg2;
95000   arg3 = (Dali::Actor *)jarg3;
95001   if (!arg3) {
95002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95003     return ;
95004   }
95005   {
95006     try {
95007       try {
95008         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
95009       }
95010       catch(std::out_of_range &_e) {
95011         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95012         return ;
95013       }
95014
95015     } catch (std::out_of_range& e) {
95016       {
95017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95018       };
95019     } catch (std::exception& e) {
95020       {
95021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95022       };
95023     } catch (Dali::DaliException e) {
95024       {
95025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95026       };
95027     } catch (...) {
95028       {
95029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95030       };
95031     }
95032   }
95033
95034 }
95035
95036
95037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
95038   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95039   int arg2 ;
95040   std::vector< Dali::Actor > *arg3 = 0 ;
95041
95042   arg1 = (std::vector< Dali::Actor > *)jarg1;
95043   arg2 = (int)jarg2;
95044   arg3 = (std::vector< Dali::Actor > *)jarg3;
95045   if (!arg3) {
95046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95047     return ;
95048   }
95049   {
95050     try {
95051       try {
95052         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
95053       }
95054       catch(std::out_of_range &_e) {
95055         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95056         return ;
95057       }
95058
95059     } catch (std::out_of_range& e) {
95060       {
95061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95062       };
95063     } catch (std::exception& e) {
95064       {
95065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95066       };
95067     } catch (Dali::DaliException e) {
95068       {
95069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95070       };
95071     } catch (...) {
95072       {
95073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95074       };
95075     }
95076   }
95077
95078 }
95079
95080
95081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
95082   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95083   int arg2 ;
95084
95085   arg1 = (std::vector< Dali::Actor > *)jarg1;
95086   arg2 = (int)jarg2;
95087   {
95088     try {
95089       try {
95090         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
95091       }
95092       catch(std::out_of_range &_e) {
95093         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95094         return ;
95095       }
95096
95097     } catch (std::out_of_range& e) {
95098       {
95099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95100       };
95101     } catch (std::exception& e) {
95102       {
95103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95104       };
95105     } catch (Dali::DaliException e) {
95106       {
95107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95108       };
95109     } catch (...) {
95110       {
95111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95112       };
95113     }
95114   }
95115
95116 }
95117
95118
95119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
95120   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95121   int arg2 ;
95122   int arg3 ;
95123
95124   arg1 = (std::vector< Dali::Actor > *)jarg1;
95125   arg2 = (int)jarg2;
95126   arg3 = (int)jarg3;
95127   {
95128     try {
95129       try {
95130         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
95131       }
95132       catch(std::out_of_range &_e) {
95133         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95134         return ;
95135       }
95136       catch(std::invalid_argument &_e) {
95137         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95138         return ;
95139       }
95140
95141     } catch (std::out_of_range& e) {
95142       {
95143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95144       };
95145     } catch (std::exception& e) {
95146       {
95147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95148       };
95149     } catch (Dali::DaliException e) {
95150       {
95151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95152       };
95153     } catch (...) {
95154       {
95155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95156       };
95157     }
95158   }
95159
95160 }
95161
95162
95163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
95164   void * jresult ;
95165   Dali::Actor *arg1 = 0 ;
95166   int arg2 ;
95167   std::vector< Dali::Actor > *result = 0 ;
95168
95169   arg1 = (Dali::Actor *)jarg1;
95170   if (!arg1) {
95171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95172     return 0;
95173   }
95174   arg2 = (int)jarg2;
95175   {
95176     try {
95177       try {
95178         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
95179       }
95180       catch(std::out_of_range &_e) {
95181         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95182         return 0;
95183       }
95184
95185     } catch (std::out_of_range& e) {
95186       {
95187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95188       };
95189     } catch (std::exception& e) {
95190       {
95191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95192       };
95193     } catch (Dali::DaliException e) {
95194       {
95195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95196       };
95197     } catch (...) {
95198       {
95199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95200       };
95201     }
95202   }
95203
95204   jresult = (void *)result;
95205   return jresult;
95206 }
95207
95208
95209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
95210   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95211
95212   arg1 = (std::vector< Dali::Actor > *)jarg1;
95213   {
95214     try {
95215       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
95216     } catch (std::out_of_range& e) {
95217       {
95218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95219       };
95220     } catch (std::exception& e) {
95221       {
95222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95223       };
95224     } catch (Dali::DaliException e) {
95225       {
95226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95227       };
95228     } catch (...) {
95229       {
95230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95231       };
95232     }
95233   }
95234
95235 }
95236
95237
95238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
95239   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95240   int arg2 ;
95241   int arg3 ;
95242
95243   arg1 = (std::vector< Dali::Actor > *)jarg1;
95244   arg2 = (int)jarg2;
95245   arg3 = (int)jarg3;
95246   {
95247     try {
95248       try {
95249         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
95250       }
95251       catch(std::out_of_range &_e) {
95252         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95253         return ;
95254       }
95255       catch(std::invalid_argument &_e) {
95256         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95257         return ;
95258       }
95259
95260     } catch (std::out_of_range& e) {
95261       {
95262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95263       };
95264     } catch (std::exception& e) {
95265       {
95266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95267       };
95268     } catch (Dali::DaliException e) {
95269       {
95270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95271       };
95272     } catch (...) {
95273       {
95274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95275       };
95276     }
95277   }
95278
95279 }
95280
95281
95282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
95283   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95284   int arg2 ;
95285   std::vector< Dali::Actor > *arg3 = 0 ;
95286
95287   arg1 = (std::vector< Dali::Actor > *)jarg1;
95288   arg2 = (int)jarg2;
95289   arg3 = (std::vector< Dali::Actor > *)jarg3;
95290   if (!arg3) {
95291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95292     return ;
95293   }
95294   {
95295     try {
95296       try {
95297         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
95298       }
95299       catch(std::out_of_range &_e) {
95300         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95301         return ;
95302       }
95303
95304     } catch (std::out_of_range& e) {
95305       {
95306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95307       };
95308     } catch (std::exception& e) {
95309       {
95310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95311       };
95312     } catch (Dali::DaliException e) {
95313       {
95314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95315       };
95316     } catch (...) {
95317       {
95318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95319       };
95320     }
95321   }
95322
95323 }
95324
95325
95326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
95327   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95328
95329   arg1 = (std::vector< Dali::Actor > *)jarg1;
95330   {
95331     try {
95332       delete arg1;
95333     } catch (std::out_of_range& e) {
95334       {
95335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95336       };
95337     } catch (std::exception& e) {
95338       {
95339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95340       };
95341     } catch (Dali::DaliException e) {
95342       {
95343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95344       };
95345     } catch (...) {
95346       {
95347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95348       };
95349     }
95350   }
95351
95352 }
95353
95354
95355 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
95356   unsigned int jresult ;
95357   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95358   bool result;
95359
95360   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95361   {
95362     try {
95363       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95364     } catch (std::out_of_range& e) {
95365       {
95366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95367       };
95368     } catch (std::exception& e) {
95369       {
95370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95371       };
95372     } catch (Dali::DaliException e) {
95373       {
95374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95375       };
95376     } catch (...) {
95377       {
95378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95379       };
95380     }
95381   }
95382
95383   jresult = result;
95384   return jresult;
95385 }
95386
95387
95388 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
95389   unsigned long jresult ;
95390   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95391   std::size_t result;
95392
95393   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95394   {
95395     try {
95396       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95397     } catch (std::out_of_range& e) {
95398       {
95399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95400       };
95401     } catch (std::exception& e) {
95402       {
95403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95404       };
95405     } catch (Dali::DaliException e) {
95406       {
95407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95408       };
95409     } catch (...) {
95410       {
95411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95412       };
95413     }
95414   }
95415
95416   jresult = (unsigned long)result;
95417   return jresult;
95418 }
95419
95420
95421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
95422   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95423   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95424
95425   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95426   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95427   {
95428     try {
95429       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
95430     } catch (std::out_of_range& e) {
95431       {
95432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95433       };
95434     } catch (std::exception& e) {
95435       {
95436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95437       };
95438     } catch (Dali::DaliException e) {
95439       {
95440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95441       };
95442     } catch (...) {
95443       {
95444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95445       };
95446     }
95447   }
95448
95449 }
95450
95451
95452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
95453   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95454   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95455
95456   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95457   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95458   {
95459     try {
95460       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
95461     } catch (std::out_of_range& e) {
95462       {
95463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95464       };
95465     } catch (std::exception& e) {
95466       {
95467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95468       };
95469     } catch (Dali::DaliException e) {
95470       {
95471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95472       };
95473     } catch (...) {
95474       {
95475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95476       };
95477     }
95478   }
95479
95480 }
95481
95482
95483 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
95484   unsigned int jresult ;
95485   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95486   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
95487   bool result;
95488
95489   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95490   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
95491   if (!arg2) {
95492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
95493     return 0;
95494   }
95495   {
95496     try {
95497       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
95498     } catch (std::out_of_range& e) {
95499       {
95500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95501       };
95502     } catch (std::exception& e) {
95503       {
95504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95505       };
95506     } catch (Dali::DaliException e) {
95507       {
95508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95509       };
95510     } catch (...) {
95511       {
95512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95513       };
95514     }
95515   }
95516
95517   jresult = result;
95518   return jresult;
95519 }
95520
95521
95522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
95523   void * jresult ;
95524   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
95525
95526   {
95527     try {
95528       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
95529     } catch (std::out_of_range& e) {
95530       {
95531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95532       };
95533     } catch (std::exception& e) {
95534       {
95535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95536       };
95537     } catch (Dali::DaliException e) {
95538       {
95539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95540       };
95541     } catch (...) {
95542       {
95543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95544       };
95545     }
95546   }
95547
95548   jresult = (void *)result;
95549   return jresult;
95550 }
95551
95552
95553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
95554   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95555
95556   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95557   {
95558     try {
95559       delete arg1;
95560     } catch (std::out_of_range& e) {
95561       {
95562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95563       };
95564     } catch (std::exception& e) {
95565       {
95566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95567       };
95568     } catch (Dali::DaliException e) {
95569       {
95570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95571       };
95572     } catch (...) {
95573       {
95574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95575       };
95576     }
95577   }
95578
95579 }
95580
95581
95582 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
95583   unsigned int jresult ;
95584   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95585   bool result;
95586
95587   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95588   {
95589     try {
95590       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);
95591     } catch (std::out_of_range& e) {
95592       {
95593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95594       };
95595     } catch (std::exception& e) {
95596       {
95597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95598       };
95599     } catch (Dali::DaliException e) {
95600       {
95601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95602       };
95603     } catch (...) {
95604       {
95605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95606       };
95607     }
95608   }
95609
95610   jresult = result;
95611   return jresult;
95612 }
95613
95614
95615 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
95616   unsigned long jresult ;
95617   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95618   std::size_t result;
95619
95620   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95621   {
95622     try {
95623       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);
95624     } catch (std::out_of_range& e) {
95625       {
95626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95627       };
95628     } catch (std::exception& e) {
95629       {
95630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95631       };
95632     } catch (Dali::DaliException e) {
95633       {
95634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95635       };
95636     } catch (...) {
95637       {
95638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95639       };
95640     }
95641   }
95642
95643   jresult = (unsigned long)result;
95644   return jresult;
95645 }
95646
95647
95648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
95649   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95650   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
95651
95652   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95653   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
95654   {
95655     try {
95656       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
95657     } catch (std::out_of_range& e) {
95658       {
95659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95660       };
95661     } catch (std::exception& e) {
95662       {
95663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95664       };
95665     } catch (Dali::DaliException e) {
95666       {
95667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95668       };
95669     } catch (...) {
95670       {
95671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95672       };
95673     }
95674   }
95675
95676 }
95677
95678
95679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
95680   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95681   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
95682
95683   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95684   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
95685   {
95686     try {
95687       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
95688     } catch (std::out_of_range& e) {
95689       {
95690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95691       };
95692     } catch (std::exception& e) {
95693       {
95694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95695       };
95696     } catch (Dali::DaliException e) {
95697       {
95698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95699       };
95700     } catch (...) {
95701       {
95702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95703       };
95704     }
95705   }
95706
95707 }
95708
95709
95710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
95711   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95712   Dali::Actor arg2 ;
95713   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
95714   Dali::Actor *argp2 ;
95715
95716   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95717   argp2 = (Dali::Actor *)jarg2;
95718   if (!argp2) {
95719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95720     return ;
95721   }
95722   arg2 = *argp2;
95723   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
95724   {
95725     try {
95726       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
95727     } catch (std::out_of_range& e) {
95728       {
95729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95730       };
95731     } catch (std::exception& e) {
95732       {
95733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95734       };
95735     } catch (Dali::DaliException e) {
95736       {
95737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95738       };
95739     } catch (...) {
95740       {
95741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95742       };
95743     }
95744   }
95745
95746 }
95747
95748
95749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
95750   void * jresult ;
95751   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
95752
95753   {
95754     try {
95755       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
95756     } catch (std::out_of_range& e) {
95757       {
95758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95759       };
95760     } catch (std::exception& e) {
95761       {
95762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95763       };
95764     } catch (Dali::DaliException e) {
95765       {
95766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95767       };
95768     } catch (...) {
95769       {
95770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95771       };
95772     }
95773   }
95774
95775   jresult = (void *)result;
95776   return jresult;
95777 }
95778
95779
95780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
95781   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95782
95783   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95784   {
95785     try {
95786       delete arg1;
95787     } catch (std::out_of_range& e) {
95788       {
95789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95790       };
95791     } catch (std::exception& e) {
95792       {
95793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95794       };
95795     } catch (Dali::DaliException e) {
95796       {
95797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95798       };
95799     } catch (...) {
95800       {
95801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95802       };
95803     }
95804   }
95805
95806 }
95807
95808
95809 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
95810   unsigned int jresult ;
95811   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95812   bool result;
95813
95814   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95815   {
95816     try {
95817       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
95818     } catch (std::out_of_range& e) {
95819       {
95820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95821       };
95822     } catch (std::exception& e) {
95823       {
95824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95825       };
95826     } catch (Dali::DaliException e) {
95827       {
95828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95829       };
95830     } catch (...) {
95831       {
95832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95833       };
95834     }
95835   }
95836
95837   jresult = result;
95838   return jresult;
95839 }
95840
95841
95842 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
95843   unsigned long jresult ;
95844   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95845   std::size_t result;
95846
95847   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95848   {
95849     try {
95850       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
95851     } catch (std::out_of_range& e) {
95852       {
95853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95854       };
95855     } catch (std::exception& e) {
95856       {
95857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95858       };
95859     } catch (Dali::DaliException e) {
95860       {
95861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95862       };
95863     } catch (...) {
95864       {
95865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95866       };
95867     }
95868   }
95869
95870   jresult = (unsigned long)result;
95871   return jresult;
95872 }
95873
95874
95875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
95876   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95877   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
95878
95879   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95880   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
95881   {
95882     try {
95883       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
95884     } catch (std::out_of_range& e) {
95885       {
95886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95887       };
95888     } catch (std::exception& e) {
95889       {
95890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95891       };
95892     } catch (Dali::DaliException e) {
95893       {
95894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95895       };
95896     } catch (...) {
95897       {
95898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95899       };
95900     }
95901   }
95902
95903 }
95904
95905
95906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
95907   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95908   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
95909
95910   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95911   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
95912   {
95913     try {
95914       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
95915     } catch (std::out_of_range& e) {
95916       {
95917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95918       };
95919     } catch (std::exception& e) {
95920       {
95921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95922       };
95923     } catch (Dali::DaliException e) {
95924       {
95925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95926       };
95927     } catch (...) {
95928       {
95929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95930       };
95931     }
95932   }
95933
95934 }
95935
95936
95937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
95938   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95939   Dali::Actor arg2 ;
95940   Dali::Actor arg3 ;
95941   Dali::Actor *argp2 ;
95942   Dali::Actor *argp3 ;
95943
95944   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95945   argp2 = (Dali::Actor *)jarg2;
95946   if (!argp2) {
95947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95948     return ;
95949   }
95950   arg2 = *argp2;
95951   argp3 = (Dali::Actor *)jarg3;
95952   if (!argp3) {
95953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95954     return ;
95955   }
95956   arg3 = *argp3;
95957   {
95958     try {
95959       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
95960     } catch (std::out_of_range& e) {
95961       {
95962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95963       };
95964     } catch (std::exception& e) {
95965       {
95966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95967       };
95968     } catch (Dali::DaliException e) {
95969       {
95970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95971       };
95972     } catch (...) {
95973       {
95974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95975       };
95976     }
95977   }
95978
95979 }
95980
95981
95982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
95983   void * jresult ;
95984   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
95985
95986   {
95987     try {
95988       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
95989     } catch (std::out_of_range& e) {
95990       {
95991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95992       };
95993     } catch (std::exception& e) {
95994       {
95995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95996       };
95997     } catch (Dali::DaliException e) {
95998       {
95999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96000       };
96001     } catch (...) {
96002       {
96003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96004       };
96005     }
96006   }
96007
96008   jresult = (void *)result;
96009   return jresult;
96010 }
96011
96012
96013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
96014   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96015
96016   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96017   {
96018     try {
96019       delete arg1;
96020     } catch (std::out_of_range& e) {
96021       {
96022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96023       };
96024     } catch (std::exception& e) {
96025       {
96026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96027       };
96028     } catch (Dali::DaliException e) {
96029       {
96030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96031       };
96032     } catch (...) {
96033       {
96034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96035       };
96036     }
96037   }
96038
96039 }
96040
96041
96042 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
96043   unsigned int jresult ;
96044   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96045   bool result;
96046
96047   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96048   {
96049     try {
96050       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
96051     } catch (std::out_of_range& e) {
96052       {
96053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96054       };
96055     } catch (std::exception& e) {
96056       {
96057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96058       };
96059     } catch (Dali::DaliException e) {
96060       {
96061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96062       };
96063     } catch (...) {
96064       {
96065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96066       };
96067     }
96068   }
96069
96070   jresult = result;
96071   return jresult;
96072 }
96073
96074
96075 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
96076   unsigned long jresult ;
96077   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96078   std::size_t result;
96079
96080   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96081   {
96082     try {
96083       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
96084     } catch (std::out_of_range& e) {
96085       {
96086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96087       };
96088     } catch (std::exception& e) {
96089       {
96090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96091       };
96092     } catch (Dali::DaliException e) {
96093       {
96094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96095       };
96096     } catch (...) {
96097       {
96098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96099       };
96100     }
96101   }
96102
96103   jresult = (unsigned long)result;
96104   return jresult;
96105 }
96106
96107
96108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
96109   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96110   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
96111
96112   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96113   arg2 = (void (*)(Dali::Actor,bool))jarg2;
96114   {
96115     try {
96116       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
96117     } catch (std::out_of_range& e) {
96118       {
96119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96120       };
96121     } catch (std::exception& e) {
96122       {
96123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96124       };
96125     } catch (Dali::DaliException e) {
96126       {
96127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96128       };
96129     } catch (...) {
96130       {
96131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96132       };
96133     }
96134   }
96135
96136 }
96137
96138
96139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96140   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96141   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
96142
96143   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96144   arg2 = (void (*)(Dali::Actor,bool))jarg2;
96145   {
96146     try {
96147       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
96148     } catch (std::out_of_range& e) {
96149       {
96150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96151       };
96152     } catch (std::exception& e) {
96153       {
96154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96155       };
96156     } catch (Dali::DaliException e) {
96157       {
96158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96159       };
96160     } catch (...) {
96161       {
96162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96163       };
96164     }
96165   }
96166
96167 }
96168
96169
96170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
96171   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96172   Dali::Actor arg2 ;
96173   bool arg3 ;
96174   Dali::Actor *argp2 ;
96175
96176   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96177   argp2 = (Dali::Actor *)jarg2;
96178   if (!argp2) {
96179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96180     return ;
96181   }
96182   arg2 = *argp2;
96183   arg3 = jarg3 ? true : false;
96184   {
96185     try {
96186       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
96187     } catch (std::out_of_range& e) {
96188       {
96189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96190       };
96191     } catch (std::exception& e) {
96192       {
96193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96194       };
96195     } catch (Dali::DaliException e) {
96196       {
96197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96198       };
96199     } catch (...) {
96200       {
96201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96202       };
96203     }
96204   }
96205
96206 }
96207
96208
96209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
96210   void * jresult ;
96211   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
96212
96213   {
96214     try {
96215       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
96216     } catch (std::out_of_range& e) {
96217       {
96218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96219       };
96220     } catch (std::exception& e) {
96221       {
96222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96223       };
96224     } catch (Dali::DaliException e) {
96225       {
96226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96227       };
96228     } catch (...) {
96229       {
96230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96231       };
96232     }
96233   }
96234
96235   jresult = (void *)result;
96236   return jresult;
96237 }
96238
96239
96240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
96241   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96242
96243   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96244   {
96245     try {
96246       delete arg1;
96247     } catch (std::out_of_range& e) {
96248       {
96249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96250       };
96251     } catch (std::exception& e) {
96252       {
96253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96254       };
96255     } catch (Dali::DaliException e) {
96256       {
96257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96258       };
96259     } catch (...) {
96260       {
96261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96262       };
96263     }
96264   }
96265
96266 }
96267
96268
96269 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
96270   unsigned int jresult ;
96271   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96272   bool result;
96273
96274   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96275   {
96276     try {
96277       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);
96278     } catch (std::out_of_range& e) {
96279       {
96280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96281       };
96282     } catch (std::exception& e) {
96283       {
96284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96285       };
96286     } catch (Dali::DaliException e) {
96287       {
96288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96289       };
96290     } catch (...) {
96291       {
96292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96293       };
96294     }
96295   }
96296
96297   jresult = result;
96298   return jresult;
96299 }
96300
96301
96302 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
96303   unsigned long jresult ;
96304   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96305   std::size_t result;
96306
96307   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96308   {
96309     try {
96310       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);
96311     } catch (std::out_of_range& e) {
96312       {
96313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96314       };
96315     } catch (std::exception& e) {
96316       {
96317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96318       };
96319     } catch (Dali::DaliException e) {
96320       {
96321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96322       };
96323     } catch (...) {
96324       {
96325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96326       };
96327     }
96328   }
96329
96330   jresult = (unsigned long)result;
96331   return jresult;
96332 }
96333
96334
96335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
96336   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96337   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96338
96339   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96340   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96341   {
96342     try {
96343       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
96344     } catch (std::out_of_range& e) {
96345       {
96346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96347       };
96348     } catch (std::exception& e) {
96349       {
96350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96351       };
96352     } catch (Dali::DaliException e) {
96353       {
96354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96355       };
96356     } catch (...) {
96357       {
96358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96359       };
96360     }
96361   }
96362
96363 }
96364
96365
96366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96367   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96368   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96369
96370   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96371   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96372   {
96373     try {
96374       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
96375     } catch (std::out_of_range& e) {
96376       {
96377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96378       };
96379     } catch (std::exception& e) {
96380       {
96381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96382       };
96383     } catch (Dali::DaliException e) {
96384       {
96385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96386       };
96387     } catch (...) {
96388       {
96389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96390       };
96391     }
96392   }
96393
96394 }
96395
96396
96397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
96398   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96399   Dali::Toolkit::StyleManager arg2 ;
96400   Dali::StyleChange::Type arg3 ;
96401   Dali::Toolkit::StyleManager *argp2 ;
96402
96403   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96404   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
96405   if (!argp2) {
96406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
96407     return ;
96408   }
96409   arg2 = *argp2;
96410   arg3 = (Dali::StyleChange::Type)jarg3;
96411   {
96412     try {
96413       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
96414     } catch (std::out_of_range& e) {
96415       {
96416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96417       };
96418     } catch (std::exception& e) {
96419       {
96420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96421       };
96422     } catch (Dali::DaliException e) {
96423       {
96424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96425       };
96426     } catch (...) {
96427       {
96428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96429       };
96430     }
96431   }
96432
96433 }
96434
96435
96436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
96437   void * jresult ;
96438   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
96439
96440   {
96441     try {
96442       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
96443     } catch (std::out_of_range& e) {
96444       {
96445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96446       };
96447     } catch (std::exception& e) {
96448       {
96449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96450       };
96451     } catch (Dali::DaliException e) {
96452       {
96453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96454       };
96455     } catch (...) {
96456       {
96457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96458       };
96459     }
96460   }
96461
96462   jresult = (void *)result;
96463   return jresult;
96464 }
96465
96466
96467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
96468   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96469
96470   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96471   {
96472     try {
96473       delete arg1;
96474     } catch (std::out_of_range& e) {
96475       {
96476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96477       };
96478     } catch (std::exception& e) {
96479       {
96480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96481       };
96482     } catch (Dali::DaliException e) {
96483       {
96484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96485       };
96486     } catch (...) {
96487       {
96488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96489       };
96490     }
96491   }
96492
96493 }
96494
96495
96496 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
96497   unsigned int jresult ;
96498   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96499   bool result;
96500
96501   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96502   {
96503     try {
96504       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96505     } catch (std::out_of_range& e) {
96506       {
96507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96508       };
96509     } catch (std::exception& e) {
96510       {
96511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96512       };
96513     } catch (Dali::DaliException e) {
96514       {
96515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96516       };
96517     } catch (...) {
96518       {
96519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96520       };
96521     }
96522   }
96523
96524   jresult = result;
96525   return jresult;
96526 }
96527
96528
96529 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
96530   unsigned long jresult ;
96531   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96532   std::size_t result;
96533
96534   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96535   {
96536     try {
96537       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96538     } catch (std::out_of_range& e) {
96539       {
96540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96541       };
96542     } catch (std::exception& e) {
96543       {
96544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96545       };
96546     } catch (Dali::DaliException e) {
96547       {
96548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96549       };
96550     } catch (...) {
96551       {
96552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96553       };
96554     }
96555   }
96556
96557   jresult = (unsigned long)result;
96558   return jresult;
96559 }
96560
96561
96562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
96563   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96564   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96565
96566   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96567   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96568   {
96569     try {
96570       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
96571     } catch (std::out_of_range& e) {
96572       {
96573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96574       };
96575     } catch (std::exception& e) {
96576       {
96577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96578       };
96579     } catch (Dali::DaliException e) {
96580       {
96581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96582       };
96583     } catch (...) {
96584       {
96585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96586       };
96587     }
96588   }
96589
96590 }
96591
96592
96593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
96594   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96595   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96596
96597   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96598   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96599   {
96600     try {
96601       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
96602     } catch (std::out_of_range& e) {
96603       {
96604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96605       };
96606     } catch (std::exception& e) {
96607       {
96608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96609       };
96610     } catch (Dali::DaliException e) {
96611       {
96612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96613       };
96614     } catch (...) {
96615       {
96616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96617       };
96618     }
96619   }
96620
96621 }
96622
96623
96624 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
96625   unsigned int jresult ;
96626   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96627   Dali::Toolkit::Button arg2 ;
96628   Dali::Toolkit::Button *argp2 ;
96629   bool result;
96630
96631   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96632   argp2 = (Dali::Toolkit::Button *)jarg2;
96633   if (!argp2) {
96634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
96635     return 0;
96636   }
96637   arg2 = *argp2;
96638   {
96639     try {
96640       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
96641     } catch (std::out_of_range& e) {
96642       {
96643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96644       };
96645     } catch (std::exception& e) {
96646       {
96647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96648       };
96649     } catch (Dali::DaliException e) {
96650       {
96651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96652       };
96653     } catch (...) {
96654       {
96655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96656       };
96657     }
96658   }
96659
96660   jresult = result;
96661   return jresult;
96662 }
96663
96664
96665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
96666   void * jresult ;
96667   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
96668
96669   {
96670     try {
96671       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
96672     } catch (std::out_of_range& e) {
96673       {
96674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96675       };
96676     } catch (std::exception& e) {
96677       {
96678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96679       };
96680     } catch (Dali::DaliException e) {
96681       {
96682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96683       };
96684     } catch (...) {
96685       {
96686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96687       };
96688     }
96689   }
96690
96691   jresult = (void *)result;
96692   return jresult;
96693 }
96694
96695
96696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
96697   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96698
96699   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96700   {
96701     try {
96702       delete arg1;
96703     } catch (std::out_of_range& e) {
96704       {
96705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96706       };
96707     } catch (std::exception& e) {
96708       {
96709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96710       };
96711     } catch (Dali::DaliException e) {
96712       {
96713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96714       };
96715     } catch (...) {
96716       {
96717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96718       };
96719     }
96720   }
96721
96722 }
96723
96724
96725 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
96726   unsigned int jresult ;
96727   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96728   bool result;
96729
96730   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96731   {
96732     try {
96733       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
96734     } catch (std::out_of_range& e) {
96735       {
96736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96737       };
96738     } catch (std::exception& e) {
96739       {
96740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96741       };
96742     } catch (Dali::DaliException e) {
96743       {
96744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96745       };
96746     } catch (...) {
96747       {
96748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96749       };
96750     }
96751   }
96752
96753   jresult = result;
96754   return jresult;
96755 }
96756
96757
96758 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
96759   unsigned long jresult ;
96760   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96761   std::size_t result;
96762
96763   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96764   {
96765     try {
96766       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
96767     } catch (std::out_of_range& e) {
96768       {
96769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96770       };
96771     } catch (std::exception& e) {
96772       {
96773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96774       };
96775     } catch (Dali::DaliException e) {
96776       {
96777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96778       };
96779     } catch (...) {
96780       {
96781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96782       };
96783     }
96784   }
96785
96786   jresult = (unsigned long)result;
96787   return jresult;
96788 }
96789
96790
96791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
96792   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96793   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
96794
96795   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96796   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
96797   {
96798     try {
96799       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
96800     } catch (std::out_of_range& e) {
96801       {
96802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96803       };
96804     } catch (std::exception& e) {
96805       {
96806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96807       };
96808     } catch (Dali::DaliException e) {
96809       {
96810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96811       };
96812     } catch (...) {
96813       {
96814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96815       };
96816     }
96817   }
96818
96819 }
96820
96821
96822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
96823   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96824   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
96825
96826   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96827   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
96828   {
96829     try {
96830       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
96831     } catch (std::out_of_range& e) {
96832       {
96833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96834       };
96835     } catch (std::exception& e) {
96836       {
96837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96838       };
96839     } catch (Dali::DaliException e) {
96840       {
96841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96842       };
96843     } catch (...) {
96844       {
96845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96846       };
96847     }
96848   }
96849
96850 }
96851
96852
96853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
96854   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96855   Dali::Toolkit::GaussianBlurView arg2 ;
96856   Dali::Toolkit::GaussianBlurView *argp2 ;
96857
96858   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96859   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
96860   if (!argp2) {
96861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
96862     return ;
96863   }
96864   arg2 = *argp2;
96865   {
96866     try {
96867       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
96868     } catch (std::out_of_range& e) {
96869       {
96870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96871       };
96872     } catch (std::exception& e) {
96873       {
96874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96875       };
96876     } catch (Dali::DaliException e) {
96877       {
96878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96879       };
96880     } catch (...) {
96881       {
96882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96883       };
96884     }
96885   }
96886
96887 }
96888
96889
96890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
96891   void * jresult ;
96892   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
96893
96894   {
96895     try {
96896       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
96897     } catch (std::out_of_range& e) {
96898       {
96899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96900       };
96901     } catch (std::exception& e) {
96902       {
96903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96904       };
96905     } catch (Dali::DaliException e) {
96906       {
96907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96908       };
96909     } catch (...) {
96910       {
96911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96912       };
96913     }
96914   }
96915
96916   jresult = (void *)result;
96917   return jresult;
96918 }
96919
96920
96921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
96922   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96923
96924   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96925   {
96926     try {
96927       delete arg1;
96928     } catch (std::out_of_range& e) {
96929       {
96930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96931       };
96932     } catch (std::exception& e) {
96933       {
96934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96935       };
96936     } catch (Dali::DaliException e) {
96937       {
96938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96939       };
96940     } catch (...) {
96941       {
96942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96943       };
96944     }
96945   }
96946
96947 }
96948
96949
96950 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
96951   unsigned int jresult ;
96952   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96953   bool result;
96954
96955   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96956   {
96957     try {
96958       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);
96959     } catch (std::out_of_range& e) {
96960       {
96961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96962       };
96963     } catch (std::exception& e) {
96964       {
96965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96966       };
96967     } catch (Dali::DaliException e) {
96968       {
96969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96970       };
96971     } catch (...) {
96972       {
96973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96974       };
96975     }
96976   }
96977
96978   jresult = result;
96979   return jresult;
96980 }
96981
96982
96983 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
96984   unsigned long jresult ;
96985   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96986   std::size_t result;
96987
96988   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96989   {
96990     try {
96991       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);
96992     } catch (std::out_of_range& e) {
96993       {
96994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96995       };
96996     } catch (std::exception& e) {
96997       {
96998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96999       };
97000     } catch (Dali::DaliException e) {
97001       {
97002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97003       };
97004     } catch (...) {
97005       {
97006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97007       };
97008     }
97009   }
97010
97011   jresult = (unsigned long)result;
97012   return jresult;
97013 }
97014
97015
97016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
97017   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97018   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
97019
97020   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97021   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
97022   {
97023     try {
97024       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
97025     } catch (std::out_of_range& e) {
97026       {
97027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97028       };
97029     } catch (std::exception& e) {
97030       {
97031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97032       };
97033     } catch (Dali::DaliException e) {
97034       {
97035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97036       };
97037     } catch (...) {
97038       {
97039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97040       };
97041     }
97042   }
97043
97044 }
97045
97046
97047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
97048   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97049   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
97050
97051   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97052   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
97053   {
97054     try {
97055       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
97056     } catch (std::out_of_range& e) {
97057       {
97058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97059       };
97060     } catch (std::exception& e) {
97061       {
97062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97063       };
97064     } catch (Dali::DaliException e) {
97065       {
97066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97067       };
97068     } catch (...) {
97069       {
97070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97071       };
97072     }
97073   }
97074
97075 }
97076
97077
97078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
97079   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97080   Dali::Toolkit::PageTurnView arg2 ;
97081   unsigned int arg3 ;
97082   bool arg4 ;
97083   Dali::Toolkit::PageTurnView *argp2 ;
97084
97085   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97086   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
97087   if (!argp2) {
97088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
97089     return ;
97090   }
97091   arg2 = *argp2;
97092   arg3 = (unsigned int)jarg3;
97093   arg4 = jarg4 ? true : false;
97094   {
97095     try {
97096       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
97097     } catch (std::out_of_range& e) {
97098       {
97099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97100       };
97101     } catch (std::exception& e) {
97102       {
97103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97104       };
97105     } catch (Dali::DaliException e) {
97106       {
97107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97108       };
97109     } catch (...) {
97110       {
97111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97112       };
97113     }
97114   }
97115
97116 }
97117
97118
97119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
97120   void * jresult ;
97121   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
97122
97123   {
97124     try {
97125       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
97126     } catch (std::out_of_range& e) {
97127       {
97128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97129       };
97130     } catch (std::exception& e) {
97131       {
97132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97133       };
97134     } catch (Dali::DaliException e) {
97135       {
97136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97137       };
97138     } catch (...) {
97139       {
97140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97141       };
97142     }
97143   }
97144
97145   jresult = (void *)result;
97146   return jresult;
97147 }
97148
97149
97150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
97151   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97152
97153   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97154   {
97155     try {
97156       delete arg1;
97157     } catch (std::out_of_range& e) {
97158       {
97159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97160       };
97161     } catch (std::exception& e) {
97162       {
97163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97164       };
97165     } catch (Dali::DaliException e) {
97166       {
97167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97168       };
97169     } catch (...) {
97170       {
97171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97172       };
97173     }
97174   }
97175
97176 }
97177
97178
97179 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
97180   unsigned int jresult ;
97181   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97182   bool result;
97183
97184   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97185   {
97186     try {
97187       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
97188     } catch (std::out_of_range& e) {
97189       {
97190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97191       };
97192     } catch (std::exception& e) {
97193       {
97194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97195       };
97196     } catch (Dali::DaliException e) {
97197       {
97198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97199       };
97200     } catch (...) {
97201       {
97202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97203       };
97204     }
97205   }
97206
97207   jresult = result;
97208   return jresult;
97209 }
97210
97211
97212 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
97213   unsigned long jresult ;
97214   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97215   std::size_t result;
97216
97217   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97218   {
97219     try {
97220       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
97221     } catch (std::out_of_range& e) {
97222       {
97223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97224       };
97225     } catch (std::exception& e) {
97226       {
97227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97228       };
97229     } catch (Dali::DaliException e) {
97230       {
97231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97232       };
97233     } catch (...) {
97234       {
97235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97236       };
97237     }
97238   }
97239
97240   jresult = (unsigned long)result;
97241   return jresult;
97242 }
97243
97244
97245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
97246   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97247   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
97248
97249   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97250   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
97251   {
97252     try {
97253       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
97254     } catch (std::out_of_range& e) {
97255       {
97256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97257       };
97258     } catch (std::exception& e) {
97259       {
97260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97261       };
97262     } catch (Dali::DaliException e) {
97263       {
97264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97265       };
97266     } catch (...) {
97267       {
97268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97269       };
97270     }
97271   }
97272
97273 }
97274
97275
97276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
97277   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97278   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
97279
97280   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97281   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
97282   {
97283     try {
97284       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
97285     } catch (std::out_of_range& e) {
97286       {
97287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97288       };
97289     } catch (std::exception& e) {
97290       {
97291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97292       };
97293     } catch (Dali::DaliException e) {
97294       {
97295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97296       };
97297     } catch (...) {
97298       {
97299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97300       };
97301     }
97302   }
97303
97304 }
97305
97306
97307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
97308   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97309   Dali::Toolkit::PageTurnView arg2 ;
97310   Dali::Toolkit::PageTurnView *argp2 ;
97311
97312   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97313   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
97314   if (!argp2) {
97315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
97316     return ;
97317   }
97318   arg2 = *argp2;
97319   {
97320     try {
97321       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
97322     } catch (std::out_of_range& e) {
97323       {
97324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97325       };
97326     } catch (std::exception& e) {
97327       {
97328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97329       };
97330     } catch (Dali::DaliException e) {
97331       {
97332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97333       };
97334     } catch (...) {
97335       {
97336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97337       };
97338     }
97339   }
97340
97341 }
97342
97343
97344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
97345   void * jresult ;
97346   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
97347
97348   {
97349     try {
97350       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
97351     } catch (std::out_of_range& e) {
97352       {
97353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97354       };
97355     } catch (std::exception& e) {
97356       {
97357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97358       };
97359     } catch (Dali::DaliException e) {
97360       {
97361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97362       };
97363     } catch (...) {
97364       {
97365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97366       };
97367     }
97368   }
97369
97370   jresult = (void *)result;
97371   return jresult;
97372 }
97373
97374
97375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
97376   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97377
97378   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97379   {
97380     try {
97381       delete arg1;
97382     } catch (std::out_of_range& e) {
97383       {
97384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97385       };
97386     } catch (std::exception& e) {
97387       {
97388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97389       };
97390     } catch (Dali::DaliException e) {
97391       {
97392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97393       };
97394     } catch (...) {
97395       {
97396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97397       };
97398     }
97399   }
97400
97401 }
97402
97403
97404 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
97405   unsigned int jresult ;
97406   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97407   bool result;
97408
97409   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97410   {
97411     try {
97412       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);
97413     } catch (std::out_of_range& e) {
97414       {
97415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97416       };
97417     } catch (std::exception& e) {
97418       {
97419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97420       };
97421     } catch (Dali::DaliException e) {
97422       {
97423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97424       };
97425     } catch (...) {
97426       {
97427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97428       };
97429     }
97430   }
97431
97432   jresult = result;
97433   return jresult;
97434 }
97435
97436
97437 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
97438   unsigned long jresult ;
97439   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97440   std::size_t result;
97441
97442   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97443   {
97444     try {
97445       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);
97446     } catch (std::out_of_range& e) {
97447       {
97448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97449       };
97450     } catch (std::exception& e) {
97451       {
97452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97453       };
97454     } catch (Dali::DaliException e) {
97455       {
97456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97457       };
97458     } catch (...) {
97459       {
97460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97461       };
97462     }
97463   }
97464
97465   jresult = (unsigned long)result;
97466   return jresult;
97467 }
97468
97469
97470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
97471   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97472   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97473
97474   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97475   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97476   {
97477     try {
97478       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
97479     } catch (std::out_of_range& e) {
97480       {
97481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97482       };
97483     } catch (std::exception& e) {
97484       {
97485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97486       };
97487     } catch (Dali::DaliException e) {
97488       {
97489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97490       };
97491     } catch (...) {
97492       {
97493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97494       };
97495     }
97496   }
97497
97498 }
97499
97500
97501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
97502   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97503   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97504
97505   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97506   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97507   {
97508     try {
97509       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
97510     } catch (std::out_of_range& e) {
97511       {
97512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97513       };
97514     } catch (std::exception& e) {
97515       {
97516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97517       };
97518     } catch (Dali::DaliException e) {
97519       {
97520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97521       };
97522     } catch (...) {
97523       {
97524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97525       };
97526     }
97527   }
97528
97529 }
97530
97531
97532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
97533   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97534   Dali::Toolkit::ProgressBar arg2 ;
97535   float arg3 ;
97536   float arg4 ;
97537   Dali::Toolkit::ProgressBar *argp2 ;
97538
97539   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97540   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
97541   if (!argp2) {
97542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
97543     return ;
97544   }
97545   arg2 = *argp2;
97546   arg3 = (float)jarg3;
97547   arg4 = (float)jarg4;
97548   {
97549     try {
97550       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
97551     } catch (std::out_of_range& e) {
97552       {
97553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97554       };
97555     } catch (std::exception& e) {
97556       {
97557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97558       };
97559     } catch (Dali::DaliException e) {
97560       {
97561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97562       };
97563     } catch (...) {
97564       {
97565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97566       };
97567     }
97568   }
97569
97570 }
97571
97572
97573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
97574   void * jresult ;
97575   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
97576
97577   {
97578     try {
97579       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
97580     } catch (std::out_of_range& e) {
97581       {
97582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97583       };
97584     } catch (std::exception& e) {
97585       {
97586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97587       };
97588     } catch (Dali::DaliException e) {
97589       {
97590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97591       };
97592     } catch (...) {
97593       {
97594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97595       };
97596     }
97597   }
97598
97599   jresult = (void *)result;
97600   return jresult;
97601 }
97602
97603
97604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
97605   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97606
97607   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97608   {
97609     try {
97610       delete arg1;
97611     } catch (std::out_of_range& e) {
97612       {
97613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97614       };
97615     } catch (std::exception& e) {
97616       {
97617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97618       };
97619     } catch (Dali::DaliException e) {
97620       {
97621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97622       };
97623     } catch (...) {
97624       {
97625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97626       };
97627     }
97628   }
97629
97630 }
97631
97632
97633 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
97634   unsigned int jresult ;
97635   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97636   bool result;
97637
97638   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97639   {
97640     try {
97641       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);
97642     } catch (std::out_of_range& e) {
97643       {
97644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97645       };
97646     } catch (std::exception& e) {
97647       {
97648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97649       };
97650     } catch (Dali::DaliException e) {
97651       {
97652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97653       };
97654     } catch (...) {
97655       {
97656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97657       };
97658     }
97659   }
97660
97661   jresult = result;
97662   return jresult;
97663 }
97664
97665
97666 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
97667   unsigned long jresult ;
97668   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97669   std::size_t result;
97670
97671   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97672   {
97673     try {
97674       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);
97675     } catch (std::out_of_range& e) {
97676       {
97677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97678       };
97679     } catch (std::exception& e) {
97680       {
97681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97682       };
97683     } catch (Dali::DaliException e) {
97684       {
97685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97686       };
97687     } catch (...) {
97688       {
97689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97690       };
97691     }
97692   }
97693
97694   jresult = (unsigned long)result;
97695   return jresult;
97696 }
97697
97698
97699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
97700   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97701   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
97702
97703   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97704   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
97705   {
97706     try {
97707       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
97708     } catch (std::out_of_range& e) {
97709       {
97710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97711       };
97712     } catch (std::exception& e) {
97713       {
97714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97715       };
97716     } catch (Dali::DaliException e) {
97717       {
97718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97719       };
97720     } catch (...) {
97721       {
97722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97723       };
97724     }
97725   }
97726
97727 }
97728
97729
97730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
97731   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97732   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
97733
97734   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97735   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
97736   {
97737     try {
97738       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
97739     } catch (std::out_of_range& e) {
97740       {
97741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97742       };
97743     } catch (std::exception& e) {
97744       {
97745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97746       };
97747     } catch (Dali::DaliException e) {
97748       {
97749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97750       };
97751     } catch (...) {
97752       {
97753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97754       };
97755     }
97756   }
97757
97758 }
97759
97760
97761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
97762   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97763   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
97764
97765   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97766   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
97767   if (!arg2) {
97768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
97769     return ;
97770   }
97771   {
97772     try {
97773       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
97774     } catch (std::out_of_range& e) {
97775       {
97776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97777       };
97778     } catch (std::exception& e) {
97779       {
97780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97781       };
97782     } catch (Dali::DaliException e) {
97783       {
97784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97785       };
97786     } catch (...) {
97787       {
97788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97789       };
97790     }
97791   }
97792
97793 }
97794
97795
97796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
97797   void * jresult ;
97798   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
97799
97800   {
97801     try {
97802       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
97803     } catch (std::out_of_range& e) {
97804       {
97805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97806       };
97807     } catch (std::exception& e) {
97808       {
97809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97810       };
97811     } catch (Dali::DaliException e) {
97812       {
97813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97814       };
97815     } catch (...) {
97816       {
97817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97818       };
97819     }
97820   }
97821
97822   jresult = (void *)result;
97823   return jresult;
97824 }
97825
97826
97827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
97828   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97829
97830   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97831   {
97832     try {
97833       delete arg1;
97834     } catch (std::out_of_range& e) {
97835       {
97836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97837       };
97838     } catch (std::exception& e) {
97839       {
97840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97841       };
97842     } catch (Dali::DaliException e) {
97843       {
97844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97845       };
97846     } catch (...) {
97847       {
97848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97849       };
97850     }
97851   }
97852
97853 }
97854
97855
97856 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
97857   unsigned int jresult ;
97858   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97859   bool result;
97860
97861   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97862   {
97863     try {
97864       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
97865     } catch (std::out_of_range& e) {
97866       {
97867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97868       };
97869     } catch (std::exception& e) {
97870       {
97871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97872       };
97873     } catch (Dali::DaliException e) {
97874       {
97875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97876       };
97877     } catch (...) {
97878       {
97879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97880       };
97881     }
97882   }
97883
97884   jresult = result;
97885   return jresult;
97886 }
97887
97888
97889 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
97890   unsigned long jresult ;
97891   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97892   std::size_t result;
97893
97894   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97895   {
97896     try {
97897       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
97898     } catch (std::out_of_range& e) {
97899       {
97900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97901       };
97902     } catch (std::exception& e) {
97903       {
97904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97905       };
97906     } catch (Dali::DaliException e) {
97907       {
97908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97909       };
97910     } catch (...) {
97911       {
97912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97913       };
97914     }
97915   }
97916
97917   jresult = (unsigned long)result;
97918   return jresult;
97919 }
97920
97921
97922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
97923   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97924   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
97925
97926   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97927   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
97928   {
97929     try {
97930       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
97931     } catch (std::out_of_range& e) {
97932       {
97933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97934       };
97935     } catch (std::exception& e) {
97936       {
97937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97938       };
97939     } catch (Dali::DaliException e) {
97940       {
97941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97942       };
97943     } catch (...) {
97944       {
97945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97946       };
97947     }
97948   }
97949
97950 }
97951
97952
97953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
97954   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97955   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
97956
97957   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97958   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
97959   {
97960     try {
97961       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
97962     } catch (std::out_of_range& e) {
97963       {
97964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97965       };
97966     } catch (std::exception& e) {
97967       {
97968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97969       };
97970     } catch (Dali::DaliException e) {
97971       {
97972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97973       };
97974     } catch (...) {
97975       {
97976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97977       };
97978     }
97979   }
97980
97981 }
97982
97983
97984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
97985   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97986   Dali::Vector2 *arg2 = 0 ;
97987
97988   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97989   arg2 = (Dali::Vector2 *)jarg2;
97990   if (!arg2) {
97991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
97992     return ;
97993   }
97994   {
97995     try {
97996       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
97997     } catch (std::out_of_range& e) {
97998       {
97999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98000       };
98001     } catch (std::exception& e) {
98002       {
98003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98004       };
98005     } catch (Dali::DaliException e) {
98006       {
98007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98008       };
98009     } catch (...) {
98010       {
98011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98012       };
98013     }
98014   }
98015
98016 }
98017
98018
98019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
98020   void * jresult ;
98021   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
98022
98023   {
98024     try {
98025       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
98026     } catch (std::out_of_range& e) {
98027       {
98028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98029       };
98030     } catch (std::exception& e) {
98031       {
98032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98033       };
98034     } catch (Dali::DaliException e) {
98035       {
98036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98037       };
98038     } catch (...) {
98039       {
98040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98041       };
98042     }
98043   }
98044
98045   jresult = (void *)result;
98046   return jresult;
98047 }
98048
98049
98050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
98051   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98052
98053   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98054   {
98055     try {
98056       delete arg1;
98057     } catch (std::out_of_range& e) {
98058       {
98059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98060       };
98061     } catch (std::exception& e) {
98062       {
98063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98064       };
98065     } catch (Dali::DaliException e) {
98066       {
98067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98068       };
98069     } catch (...) {
98070       {
98071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98072       };
98073     }
98074   }
98075
98076 }
98077
98078
98079
98080 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
98081   unsigned int jresult ;
98082   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98083   bool result;
98084
98085   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98086   {
98087     try {
98088       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);
98089     } catch (std::out_of_range& e) {
98090       {
98091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98092       };
98093     } catch (std::exception& e) {
98094       {
98095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98096       };
98097     } catch (Dali::DaliException e) {
98098       {
98099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98100       };
98101     } catch (...) {
98102       {
98103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98104       };
98105     }
98106   }
98107
98108   jresult = result;
98109   return jresult;
98110 }
98111
98112
98113 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
98114   unsigned long jresult ;
98115   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98116   std::size_t result;
98117
98118   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98119   {
98120     try {
98121       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);
98122     } catch (std::out_of_range& e) {
98123       {
98124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98125       };
98126     } catch (std::exception& e) {
98127       {
98128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98129       };
98130     } catch (Dali::DaliException e) {
98131       {
98132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98133       };
98134     } catch (...) {
98135       {
98136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98137       };
98138     }
98139   }
98140
98141   jresult = (unsigned long)result;
98142   return jresult;
98143 }
98144
98145
98146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
98147   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98148   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
98149
98150   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98151   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
98152   {
98153     try {
98154       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
98155     } catch (std::out_of_range& e) {
98156       {
98157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98158       };
98159     } catch (std::exception& e) {
98160       {
98161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98162       };
98163     } catch (Dali::DaliException e) {
98164       {
98165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98166       };
98167     } catch (...) {
98168       {
98169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98170       };
98171     }
98172   }
98173
98174 }
98175
98176
98177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
98178   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98179   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
98180
98181   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98182   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
98183   {
98184     try {
98185       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98186     } catch (std::out_of_range& e) {
98187       {
98188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98189       };
98190     } catch (std::exception& e) {
98191       {
98192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98193       };
98194     } catch (Dali::DaliException e) {
98195       {
98196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98197       };
98198     } catch (...) {
98199       {
98200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98201       };
98202     }
98203   }
98204
98205 }
98206
98207
98208 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
98209   unsigned int jresult ;
98210   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98211   Dali::Toolkit::Control arg2 ;
98212   Dali::KeyEvent *arg3 = 0 ;
98213   Dali::Toolkit::Control *argp2 ;
98214   bool result;
98215
98216   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98217   argp2 = (Dali::Toolkit::Control *)jarg2;
98218   if (!argp2) {
98219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98220     return 0;
98221   }
98222   arg2 = *argp2;
98223   arg3 = (Dali::KeyEvent *)jarg3;
98224   if (!arg3) {
98225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
98226     return 0;
98227   }
98228   {
98229     try {
98230       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);
98231     } catch (std::out_of_range& e) {
98232       {
98233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98234       };
98235     } catch (std::exception& e) {
98236       {
98237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98238       };
98239     } catch (Dali::DaliException e) {
98240       {
98241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98242       };
98243     } catch (...) {
98244       {
98245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98246       };
98247     }
98248   }
98249
98250   jresult = result;
98251   return jresult;
98252 }
98253
98254
98255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
98256   void * jresult ;
98257   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
98258
98259   {
98260     try {
98261       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
98262     } catch (std::out_of_range& e) {
98263       {
98264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98265       };
98266     } catch (std::exception& e) {
98267       {
98268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98269       };
98270     } catch (Dali::DaliException e) {
98271       {
98272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98273       };
98274     } catch (...) {
98275       {
98276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98277       };
98278     }
98279   }
98280
98281   jresult = (void *)result;
98282   return jresult;
98283 }
98284
98285
98286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
98287   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98288
98289   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98290   {
98291     try {
98292       delete arg1;
98293     } catch (std::out_of_range& e) {
98294       {
98295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98296       };
98297     } catch (std::exception& e) {
98298       {
98299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98300       };
98301     } catch (Dali::DaliException e) {
98302       {
98303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98304       };
98305     } catch (...) {
98306       {
98307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98308       };
98309     }
98310   }
98311
98312 }
98313
98314
98315 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
98316   unsigned int jresult ;
98317   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98318   bool result;
98319
98320   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98321   {
98322     try {
98323       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98324     } catch (std::out_of_range& e) {
98325       {
98326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98327       };
98328     } catch (std::exception& e) {
98329       {
98330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98331       };
98332     } catch (Dali::DaliException e) {
98333       {
98334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98335       };
98336     } catch (...) {
98337       {
98338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98339       };
98340     }
98341   }
98342
98343   jresult = result;
98344   return jresult;
98345 }
98346
98347
98348 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
98349   unsigned long jresult ;
98350   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98351   std::size_t result;
98352
98353   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98354   {
98355     try {
98356       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98357     } catch (std::out_of_range& e) {
98358       {
98359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98360       };
98361     } catch (std::exception& e) {
98362       {
98363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98364       };
98365     } catch (Dali::DaliException e) {
98366       {
98367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98368       };
98369     } catch (...) {
98370       {
98371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98372       };
98373     }
98374   }
98375
98376   jresult = (unsigned long)result;
98377   return jresult;
98378 }
98379
98380
98381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
98382   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98383   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98384
98385   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98386   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98387   {
98388     try {
98389       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
98390     } catch (std::out_of_range& e) {
98391       {
98392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98393       };
98394     } catch (std::exception& e) {
98395       {
98396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98397       };
98398     } catch (Dali::DaliException e) {
98399       {
98400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98401       };
98402     } catch (...) {
98403       {
98404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98405       };
98406     }
98407   }
98408
98409 }
98410
98411
98412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
98413   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98414   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98415
98416   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98417   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98418   {
98419     try {
98420       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
98421     } catch (std::out_of_range& e) {
98422       {
98423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98424       };
98425     } catch (std::exception& e) {
98426       {
98427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98428       };
98429     } catch (Dali::DaliException e) {
98430       {
98431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98432       };
98433     } catch (...) {
98434       {
98435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98436       };
98437     }
98438   }
98439
98440 }
98441
98442
98443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
98444   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98445   Dali::Toolkit::Control arg2 ;
98446   Dali::Toolkit::Control *argp2 ;
98447
98448   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98449   argp2 = (Dali::Toolkit::Control *)jarg2;
98450   if (!argp2) {
98451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98452     return ;
98453   }
98454   arg2 = *argp2;
98455   {
98456     try {
98457       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
98458     } catch (std::out_of_range& e) {
98459       {
98460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98461       };
98462     } catch (std::exception& e) {
98463       {
98464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98465       };
98466     } catch (Dali::DaliException e) {
98467       {
98468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98469       };
98470     } catch (...) {
98471       {
98472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98473       };
98474     }
98475   }
98476
98477 }
98478
98479
98480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
98481   void * jresult ;
98482   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
98483
98484   {
98485     try {
98486       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
98487     } catch (std::out_of_range& e) {
98488       {
98489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98490       };
98491     } catch (std::exception& e) {
98492       {
98493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98494       };
98495     } catch (Dali::DaliException e) {
98496       {
98497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98498       };
98499     } catch (...) {
98500       {
98501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98502       };
98503     }
98504   }
98505
98506   jresult = (void *)result;
98507   return jresult;
98508 }
98509
98510
98511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
98512   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98513
98514   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98515   {
98516     try {
98517       delete arg1;
98518     } catch (std::out_of_range& e) {
98519       {
98520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98521       };
98522     } catch (std::exception& e) {
98523       {
98524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98525       };
98526     } catch (Dali::DaliException e) {
98527       {
98528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98529       };
98530     } catch (...) {
98531       {
98532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98533       };
98534     }
98535   }
98536
98537 }
98538
98539
98540 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
98541   unsigned int jresult ;
98542   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98543   bool result;
98544
98545   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98546   {
98547     try {
98548       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98549     } catch (std::out_of_range& e) {
98550       {
98551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98552       };
98553     } catch (std::exception& e) {
98554       {
98555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98556       };
98557     } catch (Dali::DaliException e) {
98558       {
98559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98560       };
98561     } catch (...) {
98562       {
98563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98564       };
98565     }
98566   }
98567
98568   jresult = result;
98569   return jresult;
98570 }
98571
98572
98573 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
98574   unsigned long jresult ;
98575   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98576   std::size_t result;
98577
98578   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98579   {
98580     try {
98581       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98582     } catch (std::out_of_range& e) {
98583       {
98584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98585       };
98586     } catch (std::exception& e) {
98587       {
98588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98589       };
98590     } catch (Dali::DaliException e) {
98591       {
98592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98593       };
98594     } catch (...) {
98595       {
98596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98597       };
98598     }
98599   }
98600
98601   jresult = (unsigned long)result;
98602   return jresult;
98603 }
98604
98605
98606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
98607   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98608   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
98609
98610   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98611   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
98612   {
98613     try {
98614       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
98615     } catch (std::out_of_range& e) {
98616       {
98617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98618       };
98619     } catch (std::exception& e) {
98620       {
98621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98622       };
98623     } catch (Dali::DaliException e) {
98624       {
98625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98626       };
98627     } catch (...) {
98628       {
98629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98630       };
98631     }
98632   }
98633
98634 }
98635
98636
98637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
98638   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98639   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
98640
98641   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98642   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
98643   {
98644     try {
98645       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
98646     } catch (std::out_of_range& e) {
98647       {
98648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98649       };
98650     } catch (std::exception& e) {
98651       {
98652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98653       };
98654     } catch (Dali::DaliException e) {
98655       {
98656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98657       };
98658     } catch (...) {
98659       {
98660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98661       };
98662     }
98663   }
98664
98665 }
98666
98667
98668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
98669   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98670   Dali::Toolkit::VideoView *arg2 = 0 ;
98671
98672   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98673   arg2 = (Dali::Toolkit::VideoView *)jarg2;
98674   if (!arg2) {
98675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
98676     return ;
98677   }
98678   {
98679     try {
98680       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
98681     } catch (std::out_of_range& e) {
98682       {
98683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98684       };
98685     } catch (std::exception& e) {
98686       {
98687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98688       };
98689     } catch (Dali::DaliException e) {
98690       {
98691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98692       };
98693     } catch (...) {
98694       {
98695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98696       };
98697     }
98698   }
98699
98700 }
98701
98702
98703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
98704   void * jresult ;
98705   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
98706
98707   {
98708     try {
98709       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
98710     } catch (std::out_of_range& e) {
98711       {
98712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98713       };
98714     } catch (std::exception& e) {
98715       {
98716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98717       };
98718     } catch (Dali::DaliException e) {
98719       {
98720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98721       };
98722     } catch (...) {
98723       {
98724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98725       };
98726     }
98727   }
98728
98729   jresult = (void *)result;
98730   return jresult;
98731 }
98732
98733
98734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
98735   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98736
98737   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98738   {
98739     try {
98740       delete arg1;
98741     } catch (std::out_of_range& e) {
98742       {
98743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98744       };
98745     } catch (std::exception& e) {
98746       {
98747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98748       };
98749     } catch (Dali::DaliException e) {
98750       {
98751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98752       };
98753     } catch (...) {
98754       {
98755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98756       };
98757     }
98758   }
98759
98760 }
98761
98762
98763 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
98764   unsigned int jresult ;
98765   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98766   bool result;
98767
98768   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98769   {
98770     try {
98771       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
98772     } catch (std::out_of_range& e) {
98773       {
98774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98775       };
98776     } catch (std::exception& e) {
98777       {
98778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98779       };
98780     } catch (Dali::DaliException e) {
98781       {
98782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98783       };
98784     } catch (...) {
98785       {
98786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98787       };
98788     }
98789   }
98790
98791   jresult = result;
98792   return jresult;
98793 }
98794
98795
98796 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
98797   unsigned long jresult ;
98798   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98799   std::size_t result;
98800
98801   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98802   {
98803     try {
98804       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
98805     } catch (std::out_of_range& e) {
98806       {
98807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98808       };
98809     } catch (std::exception& e) {
98810       {
98811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98812       };
98813     } catch (Dali::DaliException e) {
98814       {
98815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98816       };
98817     } catch (...) {
98818       {
98819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98820       };
98821     }
98822   }
98823
98824   jresult = (unsigned long)result;
98825   return jresult;
98826 }
98827
98828
98829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
98830   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98831   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
98832
98833   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98834   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
98835   {
98836     try {
98837       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
98838     } catch (std::out_of_range& e) {
98839       {
98840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98841       };
98842     } catch (std::exception& e) {
98843       {
98844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98845       };
98846     } catch (Dali::DaliException e) {
98847       {
98848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98849       };
98850     } catch (...) {
98851       {
98852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98853       };
98854     }
98855   }
98856
98857 }
98858
98859
98860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
98861   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98862   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
98863
98864   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98865   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
98866   {
98867     try {
98868       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
98869     } catch (std::out_of_range& e) {
98870       {
98871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98872       };
98873     } catch (std::exception& e) {
98874       {
98875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98876       };
98877     } catch (Dali::DaliException e) {
98878       {
98879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98880       };
98881     } catch (...) {
98882       {
98883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98884       };
98885     }
98886   }
98887
98888 }
98889
98890
98891 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
98892   unsigned int jresult ;
98893   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98894   Dali::Toolkit::Slider arg2 ;
98895   float arg3 ;
98896   Dali::Toolkit::Slider *argp2 ;
98897   bool result;
98898
98899   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98900   argp2 = (Dali::Toolkit::Slider *)jarg2;
98901   if (!argp2) {
98902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
98903     return 0;
98904   }
98905   arg2 = *argp2;
98906   arg3 = (float)jarg3;
98907   {
98908     try {
98909       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
98910     } catch (std::out_of_range& e) {
98911       {
98912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98913       };
98914     } catch (std::exception& e) {
98915       {
98916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98917       };
98918     } catch (Dali::DaliException e) {
98919       {
98920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98921       };
98922     } catch (...) {
98923       {
98924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98925       };
98926     }
98927   }
98928
98929   jresult = result;
98930   return jresult;
98931 }
98932
98933
98934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
98935   void * jresult ;
98936   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
98937
98938   {
98939     try {
98940       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
98941     } catch (std::out_of_range& e) {
98942       {
98943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98944       };
98945     } catch (std::exception& e) {
98946       {
98947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98948       };
98949     } catch (Dali::DaliException e) {
98950       {
98951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98952       };
98953     } catch (...) {
98954       {
98955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98956       };
98957     }
98958   }
98959
98960   jresult = (void *)result;
98961   return jresult;
98962 }
98963
98964
98965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
98966   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98967
98968   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98969   {
98970     try {
98971       delete arg1;
98972     } catch (std::out_of_range& e) {
98973       {
98974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98975       };
98976     } catch (std::exception& e) {
98977       {
98978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98979       };
98980     } catch (Dali::DaliException e) {
98981       {
98982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98983       };
98984     } catch (...) {
98985       {
98986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98987       };
98988     }
98989   }
98990
98991 }
98992
98993
98994 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
98995   unsigned int jresult ;
98996   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98997   bool result;
98998
98999   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99000   {
99001     try {
99002       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
99003     } catch (std::out_of_range& e) {
99004       {
99005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99006       };
99007     } catch (std::exception& e) {
99008       {
99009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99010       };
99011     } catch (Dali::DaliException e) {
99012       {
99013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99014       };
99015     } catch (...) {
99016       {
99017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99018       };
99019     }
99020   }
99021
99022   jresult = result;
99023   return jresult;
99024 }
99025
99026
99027 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
99028   unsigned long jresult ;
99029   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99030   std::size_t result;
99031
99032   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99033   {
99034     try {
99035       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
99036     } catch (std::out_of_range& e) {
99037       {
99038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99039       };
99040     } catch (std::exception& e) {
99041       {
99042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99043       };
99044     } catch (Dali::DaliException e) {
99045       {
99046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99047       };
99048     } catch (...) {
99049       {
99050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99051       };
99052     }
99053   }
99054
99055   jresult = (unsigned long)result;
99056   return jresult;
99057 }
99058
99059
99060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
99061   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99062   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
99063
99064   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99065   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
99066   {
99067     try {
99068       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
99069     } catch (std::out_of_range& e) {
99070       {
99071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99072       };
99073     } catch (std::exception& e) {
99074       {
99075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99076       };
99077     } catch (Dali::DaliException e) {
99078       {
99079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99080       };
99081     } catch (...) {
99082       {
99083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99084       };
99085     }
99086   }
99087
99088 }
99089
99090
99091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
99092   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99093   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
99094
99095   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99096   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
99097   {
99098     try {
99099       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
99100     } catch (std::out_of_range& e) {
99101       {
99102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99103       };
99104     } catch (std::exception& e) {
99105       {
99106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99107       };
99108     } catch (Dali::DaliException e) {
99109       {
99110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99111       };
99112     } catch (...) {
99113       {
99114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99115       };
99116     }
99117   }
99118
99119 }
99120
99121
99122 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
99123   unsigned int jresult ;
99124   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99125   Dali::Toolkit::Slider arg2 ;
99126   int arg3 ;
99127   Dali::Toolkit::Slider *argp2 ;
99128   bool result;
99129
99130   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99131   argp2 = (Dali::Toolkit::Slider *)jarg2;
99132   if (!argp2) {
99133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
99134     return 0;
99135   }
99136   arg2 = *argp2;
99137   arg3 = (int)jarg3;
99138   {
99139     try {
99140       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
99141     } catch (std::out_of_range& e) {
99142       {
99143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99144       };
99145     } catch (std::exception& e) {
99146       {
99147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99148       };
99149     } catch (Dali::DaliException e) {
99150       {
99151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99152       };
99153     } catch (...) {
99154       {
99155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99156       };
99157     }
99158   }
99159
99160   jresult = result;
99161   return jresult;
99162 }
99163
99164
99165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
99166   void * jresult ;
99167   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
99168
99169   {
99170     try {
99171       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
99172     } catch (std::out_of_range& e) {
99173       {
99174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99175       };
99176     } catch (std::exception& e) {
99177       {
99178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99179       };
99180     } catch (Dali::DaliException e) {
99181       {
99182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99183       };
99184     } catch (...) {
99185       {
99186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99187       };
99188     }
99189   }
99190
99191   jresult = (void *)result;
99192   return jresult;
99193 }
99194
99195
99196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
99197   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99198
99199   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99200   {
99201     try {
99202       delete arg1;
99203     } catch (std::out_of_range& e) {
99204       {
99205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99206       };
99207     } catch (std::exception& e) {
99208       {
99209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99210       };
99211     } catch (Dali::DaliException e) {
99212       {
99213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99214       };
99215     } catch (...) {
99216       {
99217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99218       };
99219     }
99220   }
99221
99222 }
99223
99224
99225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
99226   void * jresult ;
99227   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99228
99229   {
99230     try {
99231       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
99232     } catch (std::out_of_range& e) {
99233       {
99234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99235       };
99236     } catch (std::exception& e) {
99237       {
99238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99239       };
99240     } catch (Dali::DaliException e) {
99241       {
99242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99243       };
99244     } catch (...) {
99245       {
99246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99247       };
99248     }
99249   }
99250
99251   jresult = (void *)result;
99252   return jresult;
99253 }
99254
99255
99256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
99257   void * jresult ;
99258   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
99259   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99260
99261   arg1 = (Dali::Toolkit::Ruler *)jarg1;
99262   {
99263     try {
99264       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
99265     } catch (std::out_of_range& e) {
99266       {
99267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99268       };
99269     } catch (std::exception& e) {
99270       {
99271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99272       };
99273     } catch (Dali::DaliException e) {
99274       {
99275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99276       };
99277     } catch (...) {
99278       {
99279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99280       };
99281     }
99282   }
99283
99284   jresult = (void *)result;
99285   return jresult;
99286 }
99287
99288
99289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
99290   void * jresult ;
99291   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
99292   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99293
99294   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99295   if (!arg1) {
99296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99297     return 0;
99298   }
99299   {
99300     try {
99301       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
99302     } catch (std::out_of_range& e) {
99303       {
99304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99305       };
99306     } catch (std::exception& e) {
99307       {
99308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99309       };
99310     } catch (Dali::DaliException e) {
99311       {
99312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99313       };
99314     } catch (...) {
99315       {
99316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99317       };
99318     }
99319   }
99320
99321   jresult = (void *)result;
99322   return jresult;
99323 }
99324
99325
99326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
99327   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99328
99329   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99330   {
99331     try {
99332       delete arg1;
99333     } catch (std::out_of_range& e) {
99334       {
99335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99336       };
99337     } catch (std::exception& e) {
99338       {
99339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99340       };
99341     } catch (Dali::DaliException e) {
99342       {
99343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99344       };
99345     } catch (...) {
99346       {
99347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99348       };
99349     }
99350   }
99351
99352 }
99353
99354
99355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
99356   void * jresult ;
99357   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99358   Dali::Toolkit::Ruler *result = 0 ;
99359
99360   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99361   {
99362     try {
99363       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
99364     } catch (std::out_of_range& e) {
99365       {
99366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99367       };
99368     } catch (std::exception& e) {
99369       {
99370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99371       };
99372     } catch (Dali::DaliException e) {
99373       {
99374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99375       };
99376     } catch (...) {
99377       {
99378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99379       };
99380     }
99381   }
99382
99383   jresult = (void *)result;
99384   return jresult;
99385 }
99386
99387
99388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
99389   void * jresult ;
99390   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99391   Dali::Toolkit::Ruler *result = 0 ;
99392
99393   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99394   {
99395     try {
99396       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
99397     } catch (std::out_of_range& e) {
99398       {
99399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99400       };
99401     } catch (std::exception& e) {
99402       {
99403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99404       };
99405     } catch (Dali::DaliException e) {
99406       {
99407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99408       };
99409     } catch (...) {
99410       {
99411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99412       };
99413     }
99414   }
99415
99416   jresult = (void *)result;
99417   return jresult;
99418 }
99419
99420
99421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
99422   void * jresult ;
99423   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99424   Dali::Toolkit::Ruler *result = 0 ;
99425
99426   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99427   {
99428     try {
99429       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
99430     } catch (std::out_of_range& e) {
99431       {
99432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99433       };
99434     } catch (std::exception& e) {
99435       {
99436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99437       };
99438     } catch (Dali::DaliException e) {
99439       {
99440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99441       };
99442     } catch (...) {
99443       {
99444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99445       };
99446     }
99447   }
99448
99449   jresult = (void *)result;
99450   return jresult;
99451 }
99452
99453
99454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
99455   void * jresult ;
99456   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99457   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
99458   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99459
99460   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99461   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
99462   if (!arg2) {
99463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99464     return 0;
99465   }
99466   {
99467     try {
99468       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
99469     } catch (std::out_of_range& e) {
99470       {
99471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99472       };
99473     } catch (std::exception& e) {
99474       {
99475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99476       };
99477     } catch (Dali::DaliException e) {
99478       {
99479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99480       };
99481     } catch (...) {
99482       {
99483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99484       };
99485     }
99486   }
99487
99488   jresult = (void *)result;
99489   return jresult;
99490 }
99491
99492
99493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
99494   void * jresult ;
99495   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99496   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99497   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99498
99499   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99500   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99501   {
99502     try {
99503       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
99504     } catch (std::out_of_range& e) {
99505       {
99506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99507       };
99508     } catch (std::exception& e) {
99509       {
99510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99511       };
99512     } catch (Dali::DaliException e) {
99513       {
99514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99515       };
99516     } catch (...) {
99517       {
99518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99519       };
99520     }
99521   }
99522
99523   jresult = (void *)result;
99524   return jresult;
99525 }
99526
99527
99528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
99529   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99530
99531   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99532   {
99533     try {
99534       (arg1)->Reset();
99535     } catch (std::out_of_range& e) {
99536       {
99537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99538       };
99539     } catch (std::exception& e) {
99540       {
99541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99542       };
99543     } catch (Dali::DaliException e) {
99544       {
99545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99546       };
99547     } catch (...) {
99548       {
99549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99550       };
99551     }
99552   }
99553
99554 }
99555
99556
99557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
99558   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99559   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99560
99561   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99562   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99563   {
99564     try {
99565       (arg1)->Reset(arg2);
99566     } catch (std::out_of_range& e) {
99567       {
99568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99569       };
99570     } catch (std::exception& e) {
99571       {
99572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99573       };
99574     } catch (Dali::DaliException e) {
99575       {
99576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99577       };
99578     } catch (...) {
99579       {
99580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99581       };
99582     }
99583   }
99584
99585 }
99586
99587
99588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
99589   void * jresult ;
99590   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99591   Dali::Toolkit::Ruler *result = 0 ;
99592
99593   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99594   {
99595     try {
99596       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
99597     } catch (std::out_of_range& e) {
99598       {
99599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99600       };
99601     } catch (std::exception& e) {
99602       {
99603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99604       };
99605     } catch (Dali::DaliException e) {
99606       {
99607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99608       };
99609     } catch (...) {
99610       {
99611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99612       };
99613     }
99614   }
99615
99616   jresult = (void *)result;
99617   return jresult;
99618 }
99619
99620
99621 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
99622   float jresult ;
99623   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99624   float arg2 ;
99625   float arg3 ;
99626   float result;
99627
99628   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99629   arg2 = (float)jarg2;
99630   arg3 = (float)jarg3;
99631   {
99632     try {
99633       result = (float)(*arg1)->Snap(arg2,arg3);
99634     } catch (std::out_of_range& e) {
99635       {
99636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99637       };
99638     } catch (std::exception& e) {
99639       {
99640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99641       };
99642     } catch (Dali::DaliException e) {
99643       {
99644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99645       };
99646     } catch (...) {
99647       {
99648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99649       };
99650     }
99651   }
99652
99653   jresult = result;
99654   return jresult;
99655 }
99656
99657
99658 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
99659   float jresult ;
99660   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99661   float arg2 ;
99662   float result;
99663
99664   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99665   arg2 = (float)jarg2;
99666   {
99667     try {
99668       result = (float)(*arg1)->Snap(arg2);
99669     } catch (std::out_of_range& e) {
99670       {
99671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99672       };
99673     } catch (std::exception& e) {
99674       {
99675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99676       };
99677     } catch (Dali::DaliException e) {
99678       {
99679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99680       };
99681     } catch (...) {
99682       {
99683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99684       };
99685     }
99686   }
99687
99688   jresult = result;
99689   return jresult;
99690 }
99691
99692
99693 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
99694   float jresult ;
99695   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99696   unsigned int arg2 ;
99697   unsigned int *arg3 = 0 ;
99698   bool arg4 ;
99699   float result;
99700
99701   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99702   arg2 = (unsigned int)jarg2;
99703   arg3 = (unsigned int *)jarg3;
99704   arg4 = jarg4 ? true : false;
99705   {
99706     try {
99707       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
99708     } catch (std::out_of_range& e) {
99709       {
99710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99711       };
99712     } catch (std::exception& e) {
99713       {
99714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99715       };
99716     } catch (Dali::DaliException e) {
99717       {
99718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99719       };
99720     } catch (...) {
99721       {
99722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99723       };
99724     }
99725   }
99726
99727   jresult = result;
99728   return jresult;
99729 }
99730
99731
99732 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
99733   unsigned int jresult ;
99734   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99735   float arg2 ;
99736   bool arg3 ;
99737   unsigned int result;
99738
99739   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99740   arg2 = (float)jarg2;
99741   arg3 = jarg3 ? true : false;
99742   {
99743     try {
99744       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
99745     } catch (std::out_of_range& e) {
99746       {
99747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99748       };
99749     } catch (std::exception& e) {
99750       {
99751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99752       };
99753     } catch (Dali::DaliException e) {
99754       {
99755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99756       };
99757     } catch (...) {
99758       {
99759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99760       };
99761     }
99762   }
99763
99764   jresult = result;
99765   return jresult;
99766 }
99767
99768
99769 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
99770   unsigned int jresult ;
99771   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99772   unsigned int result;
99773
99774   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99775   {
99776     try {
99777       result = (unsigned int)(*arg1)->GetTotalPages();
99778     } catch (std::out_of_range& e) {
99779       {
99780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99781       };
99782     } catch (std::exception& e) {
99783       {
99784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99785       };
99786     } catch (Dali::DaliException e) {
99787       {
99788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99789       };
99790     } catch (...) {
99791       {
99792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99793       };
99794     }
99795   }
99796
99797   jresult = result;
99798   return jresult;
99799 }
99800
99801
99802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
99803   int jresult ;
99804   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99805   Dali::Toolkit::Ruler::RulerType result;
99806
99807   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99808   {
99809     try {
99810       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
99811     } catch (std::out_of_range& e) {
99812       {
99813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99814       };
99815     } catch (std::exception& e) {
99816       {
99817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99818       };
99819     } catch (Dali::DaliException e) {
99820       {
99821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99822       };
99823     } catch (...) {
99824       {
99825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99826       };
99827     }
99828   }
99829
99830   jresult = (int)result;
99831   return jresult;
99832 }
99833
99834
99835 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
99836   unsigned int jresult ;
99837   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99838   bool result;
99839
99840   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99841   {
99842     try {
99843       result = (bool)(*arg1)->IsEnabled();
99844     } catch (std::out_of_range& e) {
99845       {
99846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99847       };
99848     } catch (std::exception& e) {
99849       {
99850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99851       };
99852     } catch (Dali::DaliException e) {
99853       {
99854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99855       };
99856     } catch (...) {
99857       {
99858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99859       };
99860     }
99861   }
99862
99863   jresult = result;
99864   return jresult;
99865 }
99866
99867
99868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
99869   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99870
99871   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99872   {
99873     try {
99874       (*arg1)->Enable();
99875     } catch (std::out_of_range& e) {
99876       {
99877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99878       };
99879     } catch (std::exception& e) {
99880       {
99881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99882       };
99883     } catch (Dali::DaliException e) {
99884       {
99885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99886       };
99887     } catch (...) {
99888       {
99889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99890       };
99891     }
99892   }
99893
99894 }
99895
99896
99897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
99898   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99899
99900   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99901   {
99902     try {
99903       (*arg1)->Disable();
99904     } catch (std::out_of_range& e) {
99905       {
99906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99907       };
99908     } catch (std::exception& e) {
99909       {
99910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99911       };
99912     } catch (Dali::DaliException e) {
99913       {
99914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99915       };
99916     } catch (...) {
99917       {
99918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99919       };
99920     }
99921   }
99922
99923 }
99924
99925
99926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
99927   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99928   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
99929   Dali::Toolkit::RulerDomain *argp2 ;
99930
99931   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99932   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
99933   if (!argp2) {
99934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
99935     return ;
99936   }
99937   arg2 = *argp2;
99938   {
99939     try {
99940       (*arg1)->SetDomain(arg2);
99941     } catch (std::out_of_range& e) {
99942       {
99943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99944       };
99945     } catch (std::exception& e) {
99946       {
99947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99948       };
99949     } catch (Dali::DaliException e) {
99950       {
99951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99952       };
99953     } catch (...) {
99954       {
99955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99956       };
99957     }
99958   }
99959
99960 }
99961
99962
99963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
99964   void * jresult ;
99965   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99966   Dali::Toolkit::RulerDomain *result = 0 ;
99967
99968   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99969   {
99970     try {
99971       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
99972     } catch (std::out_of_range& e) {
99973       {
99974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99975       };
99976     } catch (std::exception& e) {
99977       {
99978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99979       };
99980     } catch (Dali::DaliException e) {
99981       {
99982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99983       };
99984     } catch (...) {
99985       {
99986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99987       };
99988     }
99989   }
99990
99991   jresult = (void *)result;
99992   return jresult;
99993 }
99994
99995
99996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
99997   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99998
99999   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100000   {
100001     try {
100002       (*arg1)->DisableDomain();
100003     } catch (std::out_of_range& e) {
100004       {
100005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100006       };
100007     } catch (std::exception& e) {
100008       {
100009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100010       };
100011     } catch (Dali::DaliException e) {
100012       {
100013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100014       };
100015     } catch (...) {
100016       {
100017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100018       };
100019     }
100020   }
100021
100022 }
100023
100024
100025 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
100026   float jresult ;
100027   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100028   float arg2 ;
100029   float arg3 ;
100030   float arg4 ;
100031   float result;
100032
100033   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100034   arg2 = (float)jarg2;
100035   arg3 = (float)jarg3;
100036   arg4 = (float)jarg4;
100037   {
100038     try {
100039       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
100040     } catch (std::out_of_range& e) {
100041       {
100042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100043       };
100044     } catch (std::exception& e) {
100045       {
100046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100047       };
100048     } catch (Dali::DaliException e) {
100049       {
100050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100051       };
100052     } catch (...) {
100053       {
100054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100055       };
100056     }
100057   }
100058
100059   jresult = result;
100060   return jresult;
100061 }
100062
100063
100064 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
100065   float jresult ;
100066   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100067   float arg2 ;
100068   float arg3 ;
100069   float result;
100070
100071   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100072   arg2 = (float)jarg2;
100073   arg3 = (float)jarg3;
100074   {
100075     try {
100076       result = (float)(*arg1)->Clamp(arg2,arg3);
100077     } catch (std::out_of_range& e) {
100078       {
100079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100080       };
100081     } catch (std::exception& e) {
100082       {
100083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100084       };
100085     } catch (Dali::DaliException e) {
100086       {
100087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100088       };
100089     } catch (...) {
100090       {
100091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100092       };
100093     }
100094   }
100095
100096   jresult = result;
100097   return jresult;
100098 }
100099
100100
100101 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
100102   float jresult ;
100103   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100104   float arg2 ;
100105   float result;
100106
100107   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100108   arg2 = (float)jarg2;
100109   {
100110     try {
100111       result = (float)(*arg1)->Clamp(arg2);
100112     } catch (std::out_of_range& e) {
100113       {
100114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100115       };
100116     } catch (std::exception& e) {
100117       {
100118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100119       };
100120     } catch (Dali::DaliException e) {
100121       {
100122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100123       };
100124     } catch (...) {
100125       {
100126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100127       };
100128     }
100129   }
100130
100131   jresult = result;
100132   return jresult;
100133 }
100134
100135
100136 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
100137   float jresult ;
100138   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100139   float arg2 ;
100140   float arg3 ;
100141   float arg4 ;
100142   Dali::Toolkit::ClampState *arg5 = 0 ;
100143   float result;
100144
100145   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100146   arg2 = (float)jarg2;
100147   arg3 = (float)jarg3;
100148   arg4 = (float)jarg4;
100149   arg5 = (Dali::Toolkit::ClampState *)jarg5;
100150   if (!arg5) {
100151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100152     return 0;
100153   }
100154   {
100155     try {
100156       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
100157     } catch (std::out_of_range& e) {
100158       {
100159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100160       };
100161     } catch (std::exception& e) {
100162       {
100163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100164       };
100165     } catch (Dali::DaliException e) {
100166       {
100167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100168       };
100169     } catch (...) {
100170       {
100171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100172       };
100173     }
100174   }
100175
100176   jresult = result;
100177   return jresult;
100178 }
100179
100180
100181 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
100182   float jresult ;
100183   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100184   float arg2 ;
100185   float arg3 ;
100186   float arg4 ;
100187   float arg5 ;
100188   float result;
100189
100190   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100191   arg2 = (float)jarg2;
100192   arg3 = (float)jarg3;
100193   arg4 = (float)jarg4;
100194   arg5 = (float)jarg5;
100195   {
100196     try {
100197       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
100198     } catch (std::out_of_range& e) {
100199       {
100200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100201       };
100202     } catch (std::exception& e) {
100203       {
100204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100205       };
100206     } catch (Dali::DaliException e) {
100207       {
100208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100209       };
100210     } catch (...) {
100211       {
100212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100213       };
100214     }
100215   }
100216
100217   jresult = result;
100218   return jresult;
100219 }
100220
100221
100222 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
100223   float jresult ;
100224   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100225   float arg2 ;
100226   float arg3 ;
100227   float arg4 ;
100228   float result;
100229
100230   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100231   arg2 = (float)jarg2;
100232   arg3 = (float)jarg3;
100233   arg4 = (float)jarg4;
100234   {
100235     try {
100236       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
100237     } catch (std::out_of_range& e) {
100238       {
100239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100240       };
100241     } catch (std::exception& e) {
100242       {
100243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100244       };
100245     } catch (Dali::DaliException e) {
100246       {
100247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100248       };
100249     } catch (...) {
100250       {
100251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100252       };
100253     }
100254   }
100255
100256   jresult = result;
100257   return jresult;
100258 }
100259
100260
100261 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
100262   float jresult ;
100263   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100264   float arg2 ;
100265   float arg3 ;
100266   float result;
100267
100268   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100269   arg2 = (float)jarg2;
100270   arg3 = (float)jarg3;
100271   {
100272     try {
100273       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
100274     } catch (std::out_of_range& e) {
100275       {
100276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100277       };
100278     } catch (std::exception& e) {
100279       {
100280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100281       };
100282     } catch (Dali::DaliException e) {
100283       {
100284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100285       };
100286     } catch (...) {
100287       {
100288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100289       };
100290     }
100291   }
100292
100293   jresult = result;
100294   return jresult;
100295 }
100296
100297
100298 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
100299   float jresult ;
100300   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100301   float arg2 ;
100302   float result;
100303
100304   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100305   arg2 = (float)jarg2;
100306   {
100307     try {
100308       result = (float)(*arg1)->SnapAndClamp(arg2);
100309     } catch (std::out_of_range& e) {
100310       {
100311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100312       };
100313     } catch (std::exception& e) {
100314       {
100315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100316       };
100317     } catch (Dali::DaliException e) {
100318       {
100319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100320       };
100321     } catch (...) {
100322       {
100323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100324       };
100325     }
100326   }
100327
100328   jresult = result;
100329   return jresult;
100330 }
100331
100332
100333 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
100334   float jresult ;
100335   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100336   float arg2 ;
100337   float arg3 ;
100338   float arg4 ;
100339   float arg5 ;
100340   Dali::Toolkit::ClampState *arg6 = 0 ;
100341   float result;
100342
100343   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100344   arg2 = (float)jarg2;
100345   arg3 = (float)jarg3;
100346   arg4 = (float)jarg4;
100347   arg5 = (float)jarg5;
100348   arg6 = (Dali::Toolkit::ClampState *)jarg6;
100349   if (!arg6) {
100350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100351     return 0;
100352   }
100353   {
100354     try {
100355       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
100356     } catch (std::out_of_range& e) {
100357       {
100358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100359       };
100360     } catch (std::exception& e) {
100361       {
100362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100363       };
100364     } catch (Dali::DaliException e) {
100365       {
100366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100367       };
100368     } catch (...) {
100369       {
100370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100371       };
100372     }
100373   }
100374
100375   jresult = result;
100376   return jresult;
100377 }
100378
100379
100380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
100381   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100382
100383   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100384   {
100385     try {
100386       (*arg1)->Reference();
100387     } catch (std::out_of_range& e) {
100388       {
100389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100390       };
100391     } catch (std::exception& e) {
100392       {
100393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100394       };
100395     } catch (Dali::DaliException e) {
100396       {
100397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100398       };
100399     } catch (...) {
100400       {
100401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100402       };
100403     }
100404   }
100405
100406 }
100407
100408
100409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
100410   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100411
100412   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100413   {
100414     try {
100415       (*arg1)->Unreference();
100416     } catch (std::out_of_range& e) {
100417       {
100418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100419       };
100420     } catch (std::exception& e) {
100421       {
100422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100423       };
100424     } catch (Dali::DaliException e) {
100425       {
100426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100427       };
100428     } catch (...) {
100429       {
100430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100431       };
100432     }
100433   }
100434
100435 }
100436
100437
100438 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
100439   int jresult ;
100440   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100441   int result;
100442
100443   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100444   {
100445     try {
100446       result = (int)(*arg1)->ReferenceCount();
100447     } catch (std::out_of_range& e) {
100448       {
100449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100450       };
100451     } catch (std::exception& e) {
100452       {
100453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100454       };
100455     } catch (Dali::DaliException e) {
100456       {
100457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100458       };
100459     } catch (...) {
100460       {
100461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100462       };
100463     }
100464   }
100465
100466   jresult = result;
100467   return jresult;
100468 }
100469
100470
100471 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
100472   unsigned int jresult ;
100473   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100474   bool result;
100475
100476   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100477   {
100478     try {
100479       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100480     } catch (std::out_of_range& e) {
100481       {
100482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100483       };
100484     } catch (std::exception& e) {
100485       {
100486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100487       };
100488     } catch (Dali::DaliException e) {
100489       {
100490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100491       };
100492     } catch (...) {
100493       {
100494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100495       };
100496     }
100497   }
100498
100499   jresult = result;
100500   return jresult;
100501 }
100502
100503
100504 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
100505   unsigned long jresult ;
100506   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100507   std::size_t result;
100508
100509   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100510   {
100511     try {
100512       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100513     } catch (std::out_of_range& e) {
100514       {
100515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100516       };
100517     } catch (std::exception& e) {
100518       {
100519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100520       };
100521     } catch (Dali::DaliException e) {
100522       {
100523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100524       };
100525     } catch (...) {
100526       {
100527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100528       };
100529     }
100530   }
100531
100532   jresult = (unsigned long)result;
100533   return jresult;
100534 }
100535
100536
100537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
100538   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100539   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100540
100541   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100542   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100543   {
100544     try {
100545       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
100546     } catch (std::out_of_range& e) {
100547       {
100548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100549       };
100550     } catch (std::exception& e) {
100551       {
100552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100553       };
100554     } catch (Dali::DaliException e) {
100555       {
100556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100557       };
100558     } catch (...) {
100559       {
100560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100561       };
100562     }
100563   }
100564
100565 }
100566
100567
100568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
100569   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100570   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100571
100572   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100573   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100574   {
100575     try {
100576       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
100577     } catch (std::out_of_range& e) {
100578       {
100579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100580       };
100581     } catch (std::exception& e) {
100582       {
100583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100584       };
100585     } catch (Dali::DaliException e) {
100586       {
100587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100588       };
100589     } catch (...) {
100590       {
100591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100592       };
100593     }
100594   }
100595
100596 }
100597
100598
100599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
100600   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100601   Dali::Toolkit::Control arg2 ;
100602   Dali::Toolkit::Control *argp2 ;
100603
100604   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100605   argp2 = (Dali::Toolkit::Control *)jarg2;
100606   if (!argp2) {
100607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
100608     return ;
100609   }
100610   arg2 = *argp2;
100611   {
100612     try {
100613       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
100614     } catch (std::out_of_range& e) {
100615       {
100616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100617       };
100618     } catch (std::exception& e) {
100619       {
100620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100621       };
100622     } catch (Dali::DaliException e) {
100623       {
100624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100625       };
100626     } catch (...) {
100627       {
100628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100629       };
100630     }
100631   }
100632
100633 }
100634
100635
100636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
100637   void * jresult ;
100638   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
100639
100640   {
100641     try {
100642       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
100643     } catch (std::out_of_range& e) {
100644       {
100645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100646       };
100647     } catch (std::exception& e) {
100648       {
100649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100650       };
100651     } catch (Dali::DaliException e) {
100652       {
100653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100654       };
100655     } catch (...) {
100656       {
100657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100658       };
100659     }
100660   }
100661
100662   jresult = (void *)result;
100663   return jresult;
100664 }
100665
100666
100667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
100668   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100669
100670   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100671   {
100672     try {
100673       delete arg1;
100674     } catch (std::out_of_range& e) {
100675       {
100676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100677       };
100678     } catch (std::exception& e) {
100679       {
100680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100681       };
100682     } catch (Dali::DaliException e) {
100683       {
100684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100685       };
100686     } catch (...) {
100687       {
100688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100689       };
100690     }
100691   }
100692
100693 }
100694
100695 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
100696   Dali::RefObject *result = NULL;
100697
100698   if (arg1)
100699   {
100700     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
100701   }
100702   return result;
100703 }
100704
100705 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
100706     return (Dali::RefObject *)jarg1;
100707 }
100708
100709 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
100710     return (Dali::SignalObserver *)jarg1;
100711 }
100712
100713 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
100714     return (Dali::ConnectionTrackerInterface *)jarg1;
100715 }
100716
100717 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
100718     return (Dali::BaseHandle *)jarg1;
100719 }
100720
100721 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
100722     return (Dali::BaseHandle *)jarg1;
100723 }
100724
100725 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
100726     return (Dali::BaseHandle *)jarg1;
100727 }
100728
100729 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
100730     return (Dali::BaseHandle *)jarg1;
100731 }
100732
100733 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
100734     return (Dali::BaseHandle *)jarg1;
100735 }
100736
100737 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
100738     return (Dali::BaseHandle *)jarg1;
100739 }
100740
100741 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
100742     return (Dali::BaseHandle *)jarg1;
100743 }
100744
100745 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
100746     return (Dali::BaseHandle *)jarg1;
100747 }
100748
100749 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
100750     return (Dali::BaseHandle *)jarg1;
100751 }
100752
100753 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
100754     return (Dali::BaseHandle *)jarg1;
100755 }
100756
100757 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
100758     return (Dali::BaseHandle *)jarg1;
100759 }
100760
100761 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
100762     return (Dali::BaseHandle *)jarg1;
100763 }
100764
100765 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
100766     return (Dali::BaseHandle *)jarg1;
100767 }
100768
100769 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
100770     return (Dali::Handle *)jarg1;
100771 }
100772
100773 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
100774     return (Dali::Handle *)jarg1;
100775 }
100776
100777 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
100778     return (Dali::BaseHandle *)jarg1;
100779 }
100780
100781 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
100782     return (Dali::BaseHandle *)jarg1;
100783 }
100784
100785 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
100786     return (Dali::Handle *)jarg1;
100787 }
100788
100789 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
100790     return (Dali::BaseHandle *)jarg1;
100791 }
100792
100793 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
100794     return (Dali::Handle *)jarg1;
100795 }
100796
100797 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
100798     return (Dali::GestureDetector *)jarg1;
100799 }
100800
100801 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
100802     return (Dali::Gesture *)jarg1;
100803 }
100804
100805 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
100806     return (Dali::Handle *)jarg1;
100807 }
100808
100809 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
100810     return (Dali::Actor *)jarg1;
100811 }
100812
100813 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
100814     return (Dali::BaseHandle *)jarg1;
100815 }
100816
100817 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
100818     return (Dali::RefObject *)jarg1;
100819 }
100820
100821 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
100822     return (Dali::Actor *)jarg1;
100823 }
100824
100825 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
100826     return (Dali::GestureDetector *)jarg1;
100827 }
100828
100829 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
100830     return (Dali::Gesture *)jarg1;
100831 }
100832
100833 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
100834     return (Dali::GestureDetector *)jarg1;
100835 }
100836
100837 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
100838     return (Dali::Gesture *)jarg1;
100839 }
100840
100841 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
100842     return (Dali::GestureDetector *)jarg1;
100843 }
100844
100845 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
100846     return (Dali::Gesture *)jarg1;
100847 }
100848
100849 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
100850     return (Dali::BaseHandle *)jarg1;
100851 }
100852
100853 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
100854     return (Dali::Handle *)jarg1;
100855 }
100856
100857 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
100858     return (Dali::Handle *)jarg1;
100859 }
100860
100861 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
100862     return (Dali::Handle *)jarg1;
100863 }
100864
100865 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
100866     return (Dali::Image *)jarg1;
100867 }
100868
100869 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
100870     return (Dali::Image *)jarg1;
100871 }
100872
100873 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
100874     return (Dali::Image *)jarg1;
100875 }
100876
100877 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
100878     return (Dali::RefObject *)jarg1;
100879 }
100880
100881 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
100882     return (Dali::Image *)jarg1;
100883 }
100884
100885 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
100886     return (Dali::Image *)jarg1;
100887 }
100888
100889 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
100890     return (Dali::ResourceImage *)jarg1;
100891 }
100892
100893 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
100894     return (Dali::Actor *)jarg1;
100895 }
100896
100897 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
100898     return (Dali::BaseHandle *)jarg1;
100899 }
100900
100901 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
100902     return (Dali::BaseHandle *)jarg1;
100903 }
100904
100905
100906 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
100907     return (Dali::BaseHandle *)jarg1;
100908 }
100909
100910 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
100911     return (Dali::BaseHandle *)jarg1;
100912 }
100913
100914 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
100915     return (Dali::CustomActorImpl *)jarg1;
100916 }
100917
100918 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
100919     return (Dali::CustomActor *)jarg1;
100920 }
100921
100922 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
100923     return (Dali::BaseHandle *)jarg1;
100924 }
100925
100926 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
100927     return (Dali::Toolkit::Control *)jarg1;
100928 }
100929
100930 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
100931     return (Dali::Toolkit::Control *)jarg1;
100932 }
100933
100934 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
100935     return (Dali::Toolkit::Button *)jarg1;
100936 }
100937
100938 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
100939     return (Dali::Toolkit::Button *)jarg1;
100940 }
100941
100942 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
100943     return (Dali::Toolkit::Button *)jarg1;
100944 }
100945
100946 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
100947     return (Dali::Toolkit::Control *)jarg1;
100948 }
100949
100950 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
100951     return (Dali::Toolkit::Control *)jarg1;
100952 }
100953
100954 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
100955     return (Dali::Toolkit::Control *)jarg1;
100956 }
100957
100958 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
100959     return (Dali::Toolkit::Control *)jarg1;
100960 }
100961
100962 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
100963     return (Dali::Toolkit::Control *)jarg1;
100964 }
100965
100966 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
100967     return (Dali::RefObject *)jarg1;
100968 }
100969
100970 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
100971     return (Dali::Toolkit::Scrollable *)jarg1;
100972 }
100973
100974 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
100975     return (Dali::BaseHandle *)jarg1;
100976 }
100977
100978 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
100979     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
100980 }
100981
100982 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
100983     return (Dali::RefObject *)jarg1;
100984 }
100985
100986 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
100987     return (Dali::Toolkit::Ruler *)jarg1;
100988 }
100989
100990 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
100991     return (Dali::Toolkit::Ruler *)jarg1;
100992 }
100993
100994 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
100995     return (Dali::Toolkit::Scrollable *)jarg1;
100996 }
100997
100998 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
100999     return (Dali::Toolkit::Control *)jarg1;
101000 }
101001
101002
101003 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
101004     return (Dali::Toolkit::Control *)jarg1;
101005 }
101006
101007 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
101008     return (Dali::BaseHandle *)jarg1;
101009 }
101010
101011 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
101012     return (Dali::BaseHandle *)jarg1;
101013 }
101014
101015 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
101016     return (Dali::Toolkit::Control *)jarg1;
101017 }
101018
101019 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
101020     return (Dali::Toolkit::Control *)jarg1;
101021 }
101022
101023 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
101024     return (Dali::Toolkit::Control *)jarg1;
101025 }
101026
101027 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
101028     return (Dali::Toolkit::Control *)jarg1;
101029 }
101030
101031 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
101032     return (Dali::Toolkit::Control *)jarg1;
101033 }
101034
101035 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
101036     return (Dali::Toolkit::Control *)jarg1;
101037 }
101038
101039 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
101040     return (Dali::Toolkit::PageTurnView *)jarg1;
101041 }
101042
101043 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
101044     return (Dali::Toolkit::PageTurnView *)jarg1;
101045 }
101046
101047 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
101048     return (Dali::Toolkit::Button *)jarg1;
101049 }
101050
101051 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
101052     return (Dali::BaseHandle *)jarg1;
101053 }
101054
101055 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
101056     return (Dali::BaseHandle *)jarg1;
101057 }
101058
101059 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
101060     return (Dali::BaseHandle *)jarg1;
101061 }
101062
101063
101064 #ifdef __cplusplus
101065 }
101066 #endif
101067