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
 470
 471 // add here SWIG version check
 472
 473 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 474 // disable Swig-dependent warnings
 475
 476 // 'identifier1' has C-linkage specified,
 477 // but returns UDT 'identifier2' which is incompatible with C
 478 #pragma warning(disable: 4190)
 479
 480 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 481 #pragma warning(disable: 4800)
 482
 483 // debug info too long etc etc
 484 #pragma warning(disable: 4786)
 485 #endif
 486
 487
 488 #include <stdexcept>
 489
 490
 491 #include <string>
 492
 493
 494 #include <vector>
 495 #include <algorithm>
 496 #include <stdexcept>
 497
 498
 499 #include <map>
 500 #include <algorithm>
 501 #include <stdexcept>
 502
 503
 504 #include <utility>
 505
 506
 507 typedef float floatp;
 508
 509 SWIGINTERN floatp *new_floatp(){
 510   return new float();
 511 }
 512 SWIGINTERN void delete_floatp(floatp *self){
 513   if (self) delete self;
 514 }
 515 SWIGINTERN void floatp_assign(floatp *self,float value){
 516   *self = value;
 517 }
 518 SWIGINTERN float floatp_value(floatp *self){
 519   return *self;
 520 }
 521 SWIGINTERN float *floatp_cast(floatp *self){
 522   return self;
 523 }
 524 SWIGINTERN floatp *floatp_frompointer(float *t){
 525   return (floatp *) t;
 526 }
 527
 528 typedef int intp;
 529
 530 SWIGINTERN intp *new_intp(){
 531   return new int();
 532 }
 533 SWIGINTERN void delete_intp(intp *self){
 534   if (self) delete self;
 535 }
 536 SWIGINTERN void intp_assign(intp *self,int value){
 537   *self = value;
 538 }
 539 SWIGINTERN int intp_value(intp *self){
 540   return *self;
 541 }
 542 SWIGINTERN int *intp_cast(intp *self){
 543   return self;
 544 }
 545 SWIGINTERN intp *intp_frompointer(int *t){
 546   return (intp *) t;
 547 }
 548
 549 typedef double doublep;
 550
 551 SWIGINTERN doublep *new_doublep(){
 552   return new double();
 553 }
 554 SWIGINTERN void delete_doublep(doublep *self){
 555   if (self) delete self;
 556 }
 557 SWIGINTERN void doublep_assign(doublep *self,double value){
 558   *self = value;
 559 }
 560 SWIGINTERN double doublep_value(doublep *self){
 561   return *self;
 562 }
 563 SWIGINTERN double *doublep_cast(doublep *self){
 564   return self;
 565 }
 566 SWIGINTERN doublep *doublep_frompointer(double *t){
 567   return (doublep *) t;
 568 }
 569
 570 typedef unsigned int uintp;
 571
 572 SWIGINTERN uintp *new_uintp(){
 573   return new unsigned int();
 574 }
 575 SWIGINTERN void delete_uintp(uintp *self){
 576   if (self) delete self;
 577 }
 578 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 579   *self = value;
 580 }
 581 SWIGINTERN unsigned int uintp_value(uintp *self){
 582   return *self;
 583 }
 584 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 585   return self;
 586 }
 587 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 588   return (uintp *) t;
 589 }
 590
 591 typedef unsigned short ushortp;
 592
 593 SWIGINTERN ushortp *new_ushortp(){
 594   return new unsigned short();
 595 }
 596 SWIGINTERN void delete_ushortp(ushortp *self){
 597   if (self) delete self;
 598 }
 599 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 600   *self = value;
 601 }
 602 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 603   return *self;
 604 }
 605 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 606   return self;
 607 }
 608 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 609   return (ushortp *) t;
 610 }
 611
 612 unsigned int int_to_uint(int x) {
 613    return (unsigned int) x;
 614 }
 615
 616
 617 using namespace Dali;
 618 using namespace Dali::Toolkit;
 619
 620 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 621 {
 622   bool result = false;
 623   try
 624   {
 625     // C++ code. DALi uses Handle <-> Body design pattern.
 626     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 627     // Handles in DALi can be converted into a boolean type
 628     // to check if the handle has a valid body attached to it.
 629     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 630     if( *self )
 631     {
 632       result = true;
 633     }
 634     else
 635     {
 636       result = false;
 637     }
 638   }
 639   catch (std::out_of_range& e)
 640   {
 641     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 642     return 0;
 643   }
 644   catch (std::exception& e)
 645   {
 646     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 647     return 0;
 648   }
 649   catch (DaliException e)
 650   {
 651     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 652     return 0;
 653   }
 654   catch (...)
 655   {
 656     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 657     return 0;
 658   }
 659   return result;
 660 }
 661
 662 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 663 {
 664   bool result = false;
 665   try
 666   {
 667     // C++ code. Check if two handles reference the same implemtion
 668     if( *self == rhs)
 669     {
 670       result = true;
 671     }
 672     else
 673     {
 674       result = false;
 675     }
 676   }
 677   catch (std::out_of_range& e)
 678   {
 679     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 680     return 0;
 681   }
 682   catch (std::exception& e)
 683   {
 684     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 685     return 0;
 686   }
 687   catch (DaliException e)
 688   {
 689     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 690     return 0;
 691   }
 692   catch (...)
 693   {
 694     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 695     return 0;
 696   }
 697   return result;
 698 }
 699
 700
 701 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 702      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 703    }
 704 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){
 705      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 706    }
 707 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 708         std::vector< Dali::TouchPoint >* pv = 0;
 709         if (capacity >= 0) {
 710           pv = new std::vector< Dali::TouchPoint >();
 711           pv->reserve(capacity);
 712        } else {
 713           throw std::out_of_range("capacity");
 714        }
 715        return pv;
 716       }
 717 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 718         if (index>=0 && index<(int)self->size())
 719           return (*self)[index];
 720         else
 721           throw std::out_of_range("index");
 722       }
 723 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 724         if (index>=0 && index<(int)self->size())
 725           return (*self)[index];
 726         else
 727           throw std::out_of_range("index");
 728       }
 729 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 730         if (index>=0 && index<(int)self->size())
 731           (*self)[index] = val;
 732         else
 733           throw std::out_of_range("index");
 734       }
 735 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 736         self->insert(self->end(), values.begin(), values.end());
 737       }
 738 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 739         if (index < 0)
 740           throw std::out_of_range("index");
 741         if (count < 0)
 742           throw std::out_of_range("count");
 743         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 744           throw std::invalid_argument("invalid range");
 745         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 746       }
 747 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 748         if (index>=0 && index<(int)self->size()+1)
 749           self->insert(self->begin()+index, x);
 750         else
 751           throw std::out_of_range("index");
 752       }
 753 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 754         if (index>=0 && index<(int)self->size()+1)
 755           self->insert(self->begin()+index, values.begin(), values.end());
 756         else
 757           throw std::out_of_range("index");
 758       }
 759 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 760         if (index>=0 && index<(int)self->size())
 761           self->erase(self->begin() + index);
 762         else
 763           throw std::out_of_range("index");
 764       }
 765 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 766         if (index < 0)
 767           throw std::out_of_range("index");
 768         if (count < 0)
 769           throw std::out_of_range("count");
 770         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 771           throw std::invalid_argument("invalid range");
 772         self->erase(self->begin()+index, self->begin()+index+count);
 773       }
 774 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 775         if (count < 0)
 776           throw std::out_of_range("count");
 777         return new std::vector< Dali::TouchPoint >(count, value);
 778       }
 779 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 780         std::reverse(self->begin(), self->end());
 781       }
 782 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 783         if (index < 0)
 784           throw std::out_of_range("index");
 785         if (count < 0)
 786           throw std::out_of_range("count");
 787         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 788           throw std::invalid_argument("invalid range");
 789         std::reverse(self->begin()+index, self->begin()+index+count);
 790       }
 791 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 792         if (index < 0)
 793           throw std::out_of_range("index");
 794         if (index+values.size() > self->size())
 795           throw std::out_of_range("index");
 796         std::copy(values.begin(), values.end(), self->begin()+index);
 797       }
 798 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 799          return self->Empty();
 800       }
 801 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 802         return self->GetConnectionCount();
 803       }
 804 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 805           self->Connect( func );
 806       }
 807 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 808           self->Disconnect( func );
 809       }
 810 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 811           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 812 /*@SWIG@*/ self->Emit( arg );
 813       }
 814 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 815          return self->Empty();
 816       }
 817 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 818         return self->GetConnectionCount();
 819       }
 820 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 821           self->Connect( func );
 822       }
 823 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 824           self->Disconnect( func );
 825       }
 826 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 827           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 828 /*@SWIG@*/ self->Emit( arg );
 829       }
 830 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 831          return self->Empty();
 832       }
 833 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){
 834         return self->GetConnectionCount();
 835       }
 836 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 *)){
 837           self->Connect( func );
 838       }
 839 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 *)){
 840           self->Disconnect( func );
 841       }
 842 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){
 843           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 844 /*@SWIG@*/ self->Emit( arg );
 845       }
 846 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 847          return self->Empty();
 848       }
 849 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 850         return self->GetConnectionCount();
 851       }
 852 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 853           self->Connect( func );
 854       }
 855 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 856           self->Disconnect( func );
 857       }
 858 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 859           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 860 /*@SWIG@*/ self->Emit( arg );
 861       }
 862 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 863          return self->Empty();
 864       }
 865 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 866         return self->GetConnectionCount();
 867       }
 868 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 869           self->Connect( func );
 870       }
 871 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 872           self->Disconnect( func );
 873       }
 874 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 875           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 876 /*@SWIG@*/ self->Emit( arg );
 877       }
 878 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){
 879          return self->Empty();
 880       }
 881 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){
 882         return self->GetConnectionCount();
 883       }
 884 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 &)){
 885         self->Connect( func );
 886       }
 887 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 &)){
 888         self->Disconnect( func );
 889       }
 890 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){
 891         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 892 /*@SWIG@*/ self->Emit( arg1, arg2 );
 893       }
 894 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){
 895          return self->Empty();
 896       }
 897 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){
 898         return self->GetConnectionCount();
 899       }
 900 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 &)){
 901         self->Connect( func );
 902       }
 903 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 &)){
 904         self->Disconnect( func );
 905       }
 906 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){
 907         return self->Emit( arg1, arg2 );
 908       }
 909 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){
 910          return self->Empty();
 911       }
 912 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){
 913         return self->GetConnectionCount();
 914       }
 915 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 &)){
 916         self->Connect( func );
 917       }
 918 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 &)){
 919         self->Disconnect( func );
 920       }
 921 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){
 922         return self->Emit( arg1, arg2 );
 923       }
 924 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){
 925          return self->Empty();
 926       }
 927 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){
 928         return self->GetConnectionCount();
 929       }
 930 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 &)){
 931         self->Connect( func );
 932       }
 933 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 &)){
 934         self->Disconnect( func );
 935       }
 936 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){
 937         return self->Emit( arg1, arg2 );
 938       }
 939 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 940          return self->Empty();
 941       }
 942 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 943         return self->GetConnectionCount();
 944       }
 945 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 946           self->Connect( func );
 947       }
 948 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 949           self->Disconnect( func );
 950       }
 951 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 952           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 953 /*@SWIG@*/ self->Emit( arg );
 954       }
 955 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 956          return self->Empty();
 957       }
 958 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){
 959         return self->GetConnectionCount();
 960       }
 961 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 &)){
 962           self->Connect( func );
 963       }
 964 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 &)){
 965           self->Disconnect( func );
 966       }
 967 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){
 968           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 969 /*@SWIG@*/ self->Emit( arg );
 970       }
 971 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 972          return self->Empty();
 973       }
 974 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){
 975         return self->GetConnectionCount();
 976       }
 977 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 &)){
 978           self->Connect( func );
 979       }
 980 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 &)){
 981           self->Disconnect( func );
 982       }
 983 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){
 984           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 985 /*@SWIG@*/ self->Emit( arg );
 986       }
 987 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 988          return self->Empty();
 989       }
 990 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){
 991         return self->GetConnectionCount();
 992       }
 993 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 &)){
 994           self->Connect( func );
 995       }
 996 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 &)){
 997           self->Disconnect( func );
 998       }
 999 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){
1000           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1001 /*@SWIG@*/ self->Emit( arg );
1002       }
1003 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){
1004          return self->Empty();
1005       }
1006 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){
1007         return self->GetConnectionCount();
1008       }
1009 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 &)){
1010         self->Connect( func );
1011       }
1012 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 &)){
1013         self->Disconnect( func );
1014       }
1015 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){
1016         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1017 /*@SWIG@*/ self->Emit( arg1, arg2 );
1018       }
1019 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){
1020          return self->Empty();
1021       }
1022 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){
1023         return self->GetConnectionCount();
1024       }
1025 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 &)){
1026         self->Connect( func );
1027       }
1028 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 &)){
1029         self->Disconnect( func );
1030       }
1031 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){
1032         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1033 /*@SWIG@*/ self->Emit( arg1, arg2 );
1034       }
1035 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){
1036          return self->Empty();
1037       }
1038 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){
1039         return self->GetConnectionCount();
1040       }
1041 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 &)){
1042         self->Connect( func );
1043       }
1044 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 &)){
1045         self->Disconnect( func );
1046       }
1047 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){
1048         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1049 /*@SWIG@*/ self->Emit( arg1, arg2 );
1050       }
1051 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1052          return self->Empty();
1053       }
1054 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1055         return self->GetConnectionCount();
1056       }
1057 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1058           self->Connect( func );
1059       }
1060 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1061           self->Disconnect( func );
1062       }
1063 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1064           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1065 /*@SWIG@*/ self->Emit( arg );
1066       }
1067 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){
1068          return self->Empty();
1069       }
1070 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){
1071         return self->GetConnectionCount();
1072       }
1073 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)){
1074           return self->Connect( func );
1075       }
1076 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)){
1077           self->Disconnect( func );
1078       }
1079 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){
1080           self->Emit( arg1, arg3 );
1081       }
1082 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){
1083          return self->Empty();
1084       }
1085 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){
1086         return self->GetConnectionCount();
1087       }
1088 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)){
1089           return self->Connect( func );
1090       }
1091 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)){
1092           self->Disconnect( func );
1093       }
1094 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){
1095           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1096 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1097       }
1098
1099 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1100          return self->Empty();
1101       }
1102 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1103         return self->GetConnectionCount();
1104       }
1105 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1106           self->Connect( func );
1107       }
1108 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1109           self->Disconnect( func );
1110       }
1111 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1112           return self->Emit();
1113       }
1114
1115 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1116         std::vector< unsigned int >* pv = 0;
1117         if (capacity >= 0) {
1118           pv = new std::vector< unsigned int >();
1119           pv->reserve(capacity);
1120        } else {
1121           throw std::out_of_range("capacity");
1122        }
1123        return pv;
1124       }
1125 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1126         if (index>=0 && index<(int)self->size())
1127           return (*self)[index];
1128         else
1129           throw std::out_of_range("index");
1130       }
1131 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1132         if (index>=0 && index<(int)self->size())
1133           return (*self)[index];
1134         else
1135           throw std::out_of_range("index");
1136       }
1137 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1138         if (index>=0 && index<(int)self->size())
1139           (*self)[index] = val;
1140         else
1141           throw std::out_of_range("index");
1142       }
1143 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1144         self->insert(self->end(), values.begin(), values.end());
1145       }
1146 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1147         if (index < 0)
1148           throw std::out_of_range("index");
1149         if (count < 0)
1150           throw std::out_of_range("count");
1151         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1152           throw std::invalid_argument("invalid range");
1153         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1154       }
1155 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1156         if (index>=0 && index<(int)self->size()+1)
1157           self->insert(self->begin()+index, x);
1158         else
1159           throw std::out_of_range("index");
1160       }
1161 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1162         if (index>=0 && index<(int)self->size()+1)
1163           self->insert(self->begin()+index, values.begin(), values.end());
1164         else
1165           throw std::out_of_range("index");
1166       }
1167 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1168         if (index>=0 && index<(int)self->size())
1169           self->erase(self->begin() + index);
1170         else
1171           throw std::out_of_range("index");
1172       }
1173 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1174         if (index < 0)
1175           throw std::out_of_range("index");
1176         if (count < 0)
1177           throw std::out_of_range("count");
1178         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1179           throw std::invalid_argument("invalid range");
1180         self->erase(self->begin()+index, self->begin()+index+count);
1181       }
1182 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1183         if (count < 0)
1184           throw std::out_of_range("count");
1185         return new std::vector< unsigned int >(count, value);
1186       }
1187 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1188         std::reverse(self->begin(), self->end());
1189       }
1190 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1191         if (index < 0)
1192           throw std::out_of_range("index");
1193         if (count < 0)
1194           throw std::out_of_range("count");
1195         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1196           throw std::invalid_argument("invalid range");
1197         std::reverse(self->begin()+index, self->begin()+index+count);
1198       }
1199 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1200         if (index < 0)
1201           throw std::out_of_range("index");
1202         if (index+values.size() > self->size())
1203           throw std::out_of_range("index");
1204         std::copy(values.begin(), values.end(), self->begin()+index);
1205       }
1206 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1207         return std::find(self->begin(), self->end(), value) != self->end();
1208       }
1209 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1210         int index = -1;
1211         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1212         if (it != self->end())
1213           index = (int)(it - self->begin());
1214         return index;
1215       }
1216 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1217         int index = -1;
1218         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1219         if (rit != self->rend())
1220           index = (int)(self->rend() - 1 - rit);
1221         return index;
1222       }
1223 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1224         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1225         if (it != self->end()) {
1226           self->erase(it);
1227           return true;
1228         }
1229         return false;
1230       }
1231 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){
1232         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1233         if (capacity >= 0) {
1234           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1235           pv->reserve(capacity);
1236        } else {
1237           throw std::out_of_range("capacity");
1238        }
1239        return pv;
1240       }
1241 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){
1242         if (index>=0 && index<(int)self->size())
1243           return (*self)[index];
1244         else
1245           throw std::out_of_range("index");
1246       }
1247 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){
1248         if (index>=0 && index<(int)self->size())
1249           return (*self)[index];
1250         else
1251           throw std::out_of_range("index");
1252       }
1253 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){
1254         if (index>=0 && index<(int)self->size())
1255           (*self)[index] = val;
1256         else
1257           throw std::out_of_range("index");
1258       }
1259 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){
1260         self->insert(self->end(), values.begin(), values.end());
1261       }
1262 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){
1263         if (index < 0)
1264           throw std::out_of_range("index");
1265         if (count < 0)
1266           throw std::out_of_range("count");
1267         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1268           throw std::invalid_argument("invalid range");
1269         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1270       }
1271 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){
1272         if (index>=0 && index<(int)self->size()+1)
1273           self->insert(self->begin()+index, x);
1274         else
1275           throw std::out_of_range("index");
1276       }
1277 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){
1278         if (index>=0 && index<(int)self->size()+1)
1279           self->insert(self->begin()+index, values.begin(), values.end());
1280         else
1281           throw std::out_of_range("index");
1282       }
1283 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){
1284         if (index>=0 && index<(int)self->size())
1285           self->erase(self->begin() + index);
1286         else
1287           throw std::out_of_range("index");
1288       }
1289 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){
1290         if (index < 0)
1291           throw std::out_of_range("index");
1292         if (count < 0)
1293           throw std::out_of_range("count");
1294         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1295           throw std::invalid_argument("invalid range");
1296         self->erase(self->begin()+index, self->begin()+index+count);
1297       }
1298 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){
1299         if (count < 0)
1300           throw std::out_of_range("count");
1301         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1302       }
1303 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){
1304         std::reverse(self->begin(), self->end());
1305       }
1306 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){
1307         if (index < 0)
1308           throw std::out_of_range("index");
1309         if (count < 0)
1310           throw std::out_of_range("count");
1311         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1312           throw std::invalid_argument("invalid range");
1313         std::reverse(self->begin()+index, self->begin()+index+count);
1314       }
1315 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){
1316         if (index < 0)
1317           throw std::out_of_range("index");
1318         if (index+values.size() > self->size())
1319           throw std::out_of_range("index");
1320         std::copy(values.begin(), values.end(), self->begin()+index);
1321       }
1322 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1323         std::vector< Dali::Actor >* pv = 0;
1324         if (capacity >= 0) {
1325           pv = new std::vector< Dali::Actor >();
1326           pv->reserve(capacity);
1327        } else {
1328           throw std::out_of_range("capacity");
1329        }
1330        return pv;
1331       }
1332 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1333         if (index>=0 && index<(int)self->size())
1334           return (*self)[index];
1335         else
1336           throw std::out_of_range("index");
1337       }
1338 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1339         if (index>=0 && index<(int)self->size())
1340           return (*self)[index];
1341         else
1342           throw std::out_of_range("index");
1343       }
1344 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1345         if (index>=0 && index<(int)self->size())
1346           (*self)[index] = val;
1347         else
1348           throw std::out_of_range("index");
1349       }
1350 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1351         self->insert(self->end(), values.begin(), values.end());
1352       }
1353 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1354         if (index < 0)
1355           throw std::out_of_range("index");
1356         if (count < 0)
1357           throw std::out_of_range("count");
1358         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1359           throw std::invalid_argument("invalid range");
1360         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1361       }
1362 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1363         if (index>=0 && index<(int)self->size()+1)
1364           self->insert(self->begin()+index, x);
1365         else
1366           throw std::out_of_range("index");
1367       }
1368 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1369         if (index>=0 && index<(int)self->size()+1)
1370           self->insert(self->begin()+index, values.begin(), values.end());
1371         else
1372           throw std::out_of_range("index");
1373       }
1374 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1375         if (index>=0 && index<(int)self->size())
1376           self->erase(self->begin() + index);
1377         else
1378           throw std::out_of_range("index");
1379       }
1380 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1381         if (index < 0)
1382           throw std::out_of_range("index");
1383         if (count < 0)
1384           throw std::out_of_range("count");
1385         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1386           throw std::invalid_argument("invalid range");
1387         self->erase(self->begin()+index, self->begin()+index+count);
1388       }
1389 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1390         if (count < 0)
1391           throw std::out_of_range("count");
1392         return new std::vector< Dali::Actor >(count, value);
1393       }
1394 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1395         std::reverse(self->begin(), self->end());
1396       }
1397 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1398         if (index < 0)
1399           throw std::out_of_range("index");
1400         if (count < 0)
1401           throw std::out_of_range("count");
1402         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1403           throw std::invalid_argument("invalid range");
1404         std::reverse(self->begin()+index, self->begin()+index+count);
1405       }
1406 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1407         if (index < 0)
1408           throw std::out_of_range("index");
1409         if (index+values.size() > self->size())
1410           throw std::out_of_range("index");
1411         std::copy(values.begin(), values.end(), self->begin()+index);
1412       }
1413 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1414          return self->Empty();
1415       }
1416 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1417         return self->GetConnectionCount();
1418       }
1419 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 &)){
1420           self->Connect( func );
1421       }
1422 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 &)){
1423           self->Disconnect( func );
1424       }
1425 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){
1426           return self->Emit( arg );
1427       }
1428 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){
1429          return self->Empty();
1430       }
1431 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){
1432         return self->GetConnectionCount();
1433       }
1434 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)){
1435         self->Connect( func );
1436       }
1437 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)){
1438         self->Disconnect( func );
1439       }
1440 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){
1441         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1442 /*@SWIG@*/ self->Emit( arg1, arg2 );
1443       }
1444 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1445          return self->Empty();
1446       }
1447 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){
1448         return self->GetConnectionCount();
1449       }
1450 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)){
1451         self->Connect( func );
1452       }
1453 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)){
1454         self->Disconnect( func );
1455       }
1456 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){
1457         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1458 /*@SWIG@*/ self->Emit( arg1, arg2 );
1459       }
1460 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1461          return self->Empty();
1462       }
1463 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1464         return self->GetConnectionCount();
1465       }
1466 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)){
1467         self->Connect( func );
1468       }
1469 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)){
1470         self->Disconnect( func );
1471       }
1472 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){
1473         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1474 /*@SWIG@*/ self->Emit( arg1, arg2 );
1475       }
1476 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){
1477          return self->Empty();
1478       }
1479 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){
1480         return self->GetConnectionCount();
1481       }
1482 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)){
1483         self->Connect( func );
1484       }
1485 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)){
1486         self->Disconnect( func );
1487       }
1488 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){
1489         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1490 /*@SWIG@*/ self->Emit( arg1, arg2 );
1491       }
1492 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1493          return self->Empty();
1494       }
1495 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1496         return self->GetConnectionCount();
1497       }
1498 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)){
1499           self->Connect( func );
1500       }
1501 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)){
1502           self->Disconnect( func );
1503       }
1504 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1505           return self->Emit( arg );
1506       }
1507 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1508          return self->Empty();
1509       }
1510 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1511         return self->GetConnectionCount();
1512       }
1513 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)){
1514           self->Connect( func );
1515       }
1516 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)){
1517           self->Disconnect( func );
1518       }
1519 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1520           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1521 /*@SWIG@*/ self->Emit( arg );
1522       }
1523 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){
1524          return self->Empty();
1525       }
1526 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){
1527         return self->GetConnectionCount();
1528       }
1529 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)){
1530           return self->Connect( func );
1531       }
1532 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)){
1533           self->Disconnect( func );
1534       }
1535 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){
1536           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1537 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1538       }
1539 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1540          return self->Empty();
1541       }
1542 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1543         return self->GetConnectionCount();
1544       }
1545 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)){
1546           self->Connect( func );
1547       }
1548 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)){
1549           self->Disconnect( func );
1550       }
1551 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1552           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1553 /*@SWIG@*/ self->Emit( arg );
1554       }
1555 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){
1556          return self->Empty();
1557       }
1558 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){
1559         return self->GetConnectionCount();
1560       }
1561 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)){
1562           return self->Connect( func );
1563       }
1564 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)){
1565           self->Disconnect( func );
1566       }
1567 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){
1568           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1569 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1570       }
1571 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){
1572          return self->Empty();
1573       }
1574 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){
1575         return self->GetConnectionCount();
1576       }
1577 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 &)){
1578           self->Connect( func );
1579       }
1580 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 &)){
1581           self->Disconnect( func );
1582       }
1583 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){
1584           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1585 /*@SWIG@*/ self->Emit( arg );
1586       }
1587 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1588          return self->Empty();
1589       }
1590 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){
1591         return self->GetConnectionCount();
1592       }
1593 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 &)){
1594           self->Connect( func );
1595       }
1596 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 &)){
1597           self->Disconnect( func );
1598       }
1599 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){
1600           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1601 /*@SWIG@*/ self->Emit( arg );
1602       }
1603
1604
1605 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){
1606          return self->Empty();
1607       }
1608 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){
1609         return self->GetConnectionCount();
1610       }
1611 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 &)){
1612         self->Connect( func );
1613       }
1614 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 &)){
1615         self->Disconnect( func );
1616       }
1617 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){
1618         return self->Emit( arg1, arg2 );
1619       }
1620 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1621          return self->Empty();
1622       }
1623 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1624         return self->GetConnectionCount();
1625       }
1626 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)){
1627           self->Connect( func );
1628       }
1629 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)){
1630           self->Disconnect( func );
1631       }
1632 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1633           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1634 /*@SWIG@*/ self->Emit( arg );
1635       }
1636 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1637          return self->Empty();
1638       }
1639 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1640         return self->GetConnectionCount();
1641       }
1642 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 &)){
1643           self->Connect( func );
1644       }
1645 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 &)){
1646           self->Disconnect( func );
1647       }
1648 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){
1649           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1650 /*@SWIG@*/ self->Emit( arg );
1651       }
1652 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1653          return self->Empty();
1654       }
1655 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){
1656         return self->GetConnectionCount();
1657       }
1658 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)){
1659         self->Connect( func );
1660       }
1661 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)){
1662         self->Disconnect( func );
1663       }
1664 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){
1665         return self->Emit( arg1, arg2 );
1666       }
1667 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1668          return self->Empty();
1669       }
1670 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){
1671         return self->GetConnectionCount();
1672       }
1673 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)){
1674         self->Connect( func );
1675       }
1676 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)){
1677         self->Disconnect( func );
1678       }
1679 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){
1680         return self->Emit( arg1, arg2 );
1681       }
1682
1683
1684 /* ---------------------------------------------------
1685  * C++ director class methods
1686  * --------------------------------------------------- */
1687
1688 #include "dali_wrap.h"
1689
1690 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1691   swig_init_callbacks();
1692 }
1693
1694 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1695
1696 }
1697
1698
1699 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1700   int jdepth  ;
1701
1702   if (!swig_callbackOnStageConnection) {
1703     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1704     return;
1705   } else {
1706     jdepth = depth;
1707     swig_callbackOnStageConnection(jdepth);
1708   }
1709 }
1710
1711 void SwigDirector_ViewImpl::OnStageDisconnection() {
1712   if (!swig_callbackOnStageDisconnection) {
1713     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1714     return;
1715   } else {
1716     swig_callbackOnStageDisconnection();
1717   }
1718 }
1719
1720 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1721   void * jchild = 0 ;
1722
1723   if (!swig_callbackOnChildAdd) {
1724     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1725     return;
1726   } else {
1727     jchild = (Dali::Actor *) &child;
1728     swig_callbackOnChildAdd(jchild);
1729   }
1730 }
1731
1732 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1733   void * jchild = 0 ;
1734
1735   if (!swig_callbackOnChildRemove) {
1736     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1737     return;
1738   } else {
1739     jchild = (Dali::Actor *) &child;
1740     swig_callbackOnChildRemove(jchild);
1741   }
1742 }
1743
1744 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1745   int jindex  ;
1746   void * jpropertyValue  ;
1747
1748   if (!swig_callbackOnPropertySet) {
1749     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1750     return;
1751   } else {
1752     jindex = index;
1753     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1754     swig_callbackOnPropertySet(jindex, jpropertyValue);
1755   }
1756 }
1757
1758 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1759   void * jtargetSize = 0 ;
1760
1761   if (!swig_callbackOnSizeSet) {
1762     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1763     return;
1764   } else {
1765     jtargetSize = (Dali::Vector3 *) &targetSize;
1766     swig_callbackOnSizeSet(jtargetSize);
1767   }
1768 }
1769
1770 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1771   void * janimation = 0 ;
1772   void * jtargetSize = 0 ;
1773
1774   if (!swig_callbackOnSizeAnimation) {
1775     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1776     return;
1777   } else {
1778     janimation = (Dali::Animation *) &animation;
1779     jtargetSize = (Dali::Vector3 *) &targetSize;
1780     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1781   }
1782 }
1783
1784 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1785   bool c_result = SwigValueInit< bool >() ;
1786   unsigned int jresult = 0 ;
1787   void * jarg0 = 0 ;
1788
1789   if (!swig_callbackOnTouchEvent) {
1790     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1791   } else {
1792     jarg0 = (Dali::TouchEvent *) &event;
1793     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1794     c_result = jresult ? true : false;
1795   }
1796   return c_result;
1797 }
1798
1799 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1800   bool c_result = SwigValueInit< bool >() ;
1801   unsigned int jresult = 0 ;
1802   void * jarg0 = 0 ;
1803
1804   if (!swig_callbackOnHoverEvent) {
1805     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1806   } else {
1807     jarg0 = (Dali::HoverEvent *) &event;
1808     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1809     c_result = jresult ? true : false;
1810   }
1811   return c_result;
1812 }
1813
1814 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1815   bool c_result = SwigValueInit< bool >() ;
1816   unsigned int jresult = 0 ;
1817   void * jarg0 = 0 ;
1818
1819   if (!swig_callbackOnKeyEvent) {
1820     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1821   } else {
1822     jarg0 = (Dali::KeyEvent *) &event;
1823     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1824     c_result = jresult ? true : false;
1825   }
1826   return c_result;
1827 }
1828
1829 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1830   bool c_result = SwigValueInit< bool >() ;
1831   unsigned int jresult = 0 ;
1832   void * jarg0 = 0 ;
1833
1834   if (!swig_callbackOnWheelEvent) {
1835     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1836   } else {
1837     jarg0 = (Dali::WheelEvent *) &event;
1838     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1839     c_result = jresult ? true : false;
1840   }
1841   return c_result;
1842 }
1843
1844 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1845   void * jsize = 0 ;
1846   void * jcontainer = 0 ;
1847
1848   if (!swig_callbackOnRelayout) {
1849     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1850     return;
1851   } else {
1852     jsize = (Dali::Vector2 *) &size;
1853     jcontainer = (Dali::RelayoutContainer *) &container;
1854     swig_callbackOnRelayout(jsize, jcontainer);
1855   }
1856 }
1857
1858 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1859   int jpolicy  ;
1860   int jdimension  ;
1861
1862   if (!swig_callbackOnSetResizePolicy) {
1863     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1864     return;
1865   } else {
1866     jpolicy = (int)policy;
1867     jdimension = (int)dimension;
1868     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1869   }
1870 }
1871
1872 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1873   Dali::Vector3 c_result ;
1874   void * jresult = 0 ;
1875
1876   if (!swig_callbackGetNaturalSize) {
1877     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1878   } else {
1879     jresult = (void *) swig_callbackGetNaturalSize();
1880     if (!jresult) {
1881       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1882       return c_result;
1883     }
1884     c_result = *(Dali::Vector3 *)jresult;
1885   }
1886   return c_result;
1887 }
1888
1889 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
1890   float c_result = SwigValueInit< float >() ;
1891   float jresult = 0 ;
1892   void * jchild = 0 ;
1893   int jdimension  ;
1894
1895   if (!swig_callbackCalculateChildSize) {
1896     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
1897   } else {
1898     jchild = (Dali::Actor *) &child;
1899     jdimension = (int)dimension;
1900     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
1901     c_result = (float)jresult;
1902   }
1903   return c_result;
1904 }
1905
1906 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
1907   float c_result = SwigValueInit< float >() ;
1908   float jresult = 0 ;
1909   float jwidth  ;
1910
1911   if (!swig_callbackGetHeightForWidth) {
1912     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
1913   } else {
1914     jwidth = width;
1915     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
1916     c_result = (float)jresult;
1917   }
1918   return c_result;
1919 }
1920
1921 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
1922   float c_result = SwigValueInit< float >() ;
1923   float jresult = 0 ;
1924   float jheight  ;
1925
1926   if (!swig_callbackGetWidthForHeight) {
1927     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
1928   } else {
1929     jheight = height;
1930     jresult = (float) swig_callbackGetWidthForHeight(jheight);
1931     c_result = (float)jresult;
1932   }
1933   return c_result;
1934 }
1935
1936 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
1937   bool c_result = SwigValueInit< bool >() ;
1938   unsigned int jresult = 0 ;
1939   int jdimension  ;
1940
1941   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
1942     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
1943   } else {
1944     jdimension = (int)dimension;
1945     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
1946     c_result = jresult ? true : false;
1947   }
1948   return c_result;
1949 }
1950
1951 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
1952   int jdimension  ;
1953
1954   if (!swig_callbackOnCalculateRelayoutSize) {
1955     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
1956     return;
1957   } else {
1958     jdimension = (int)dimension;
1959     swig_callbackOnCalculateRelayoutSize(jdimension);
1960   }
1961 }
1962
1963 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
1964   float jsize  ;
1965   int jdimension  ;
1966
1967   if (!swig_callbackOnLayoutNegotiated) {
1968     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
1969     return;
1970   } else {
1971     jsize = size;
1972     jdimension = (int)dimension;
1973     swig_callbackOnLayoutNegotiated(jsize, jdimension);
1974   }
1975 }
1976
1977 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
1978   return Dali::CustomActorImpl::GetExtension();
1979 }
1980
1981 void SwigDirector_ViewImpl::OnInitialize() {
1982   if (!swig_callbackOnInitialize) {
1983     Dali::Toolkit::Internal::Control::OnInitialize();
1984     return;
1985   } else {
1986     swig_callbackOnInitialize();
1987   }
1988 }
1989
1990 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
1991   void * jchild = 0 ;
1992
1993   if (!swig_callbackOnControlChildAdd) {
1994     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
1995     return;
1996   } else {
1997     jchild = (Dali::Actor *) &child;
1998     swig_callbackOnControlChildAdd(jchild);
1999   }
2000 }
2001
2002 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
2003   void * jchild = 0 ;
2004
2005   if (!swig_callbackOnControlChildRemove) {
2006     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
2007     return;
2008   } else {
2009     jchild = (Dali::Actor *) &child;
2010     swig_callbackOnControlChildRemove(jchild);
2011   }
2012 }
2013
2014 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2015   void * jstyleManager  ;
2016   int jchange  ;
2017
2018   if (!swig_callbackOnStyleChange) {
2019     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2020     return;
2021   } else {
2022     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2023     jchange = (int)change;
2024     swig_callbackOnStyleChange(jstyleManager, jchange);
2025   }
2026 }
2027
2028 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2029   bool c_result = SwigValueInit< bool >() ;
2030   unsigned int jresult = 0 ;
2031
2032   if (!swig_callbackOnAccessibilityActivated) {
2033     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2034   } else {
2035     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2036     c_result = jresult ? true : false;
2037   }
2038   return c_result;
2039 }
2040
2041 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2042   bool c_result = SwigValueInit< bool >() ;
2043   unsigned int jresult = 0 ;
2044   void * jgesture  ;
2045
2046   if (!swig_callbackOnAccessibilityPan) {
2047     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2048   } else {
2049     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2050     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2051     c_result = jresult ? true : false;
2052   }
2053   return c_result;
2054 }
2055
2056 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2057   bool c_result = SwigValueInit< bool >() ;
2058   unsigned int jresult = 0 ;
2059   void * jtouchEvent = 0 ;
2060
2061   if (!swig_callbackOnAccessibilityTouch) {
2062     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2063   } else {
2064     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2065     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2066     c_result = jresult ? true : false;
2067   }
2068   return c_result;
2069 }
2070
2071 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2072   bool c_result = SwigValueInit< bool >() ;
2073   unsigned int jresult = 0 ;
2074   unsigned int jisIncrease  ;
2075
2076   if (!swig_callbackOnAccessibilityValueChange) {
2077     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2078   } else {
2079     jisIncrease = isIncrease;
2080     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2081     c_result = jresult ? true : false;
2082   }
2083   return c_result;
2084 }
2085
2086 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2087   bool c_result = SwigValueInit< bool >() ;
2088   unsigned int jresult = 0 ;
2089
2090   if (!swig_callbackOnAccessibilityZoom) {
2091     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2092   } else {
2093     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2094     c_result = jresult ? true : false;
2095   }
2096   return c_result;
2097 }
2098
2099 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2100   if (!swig_callbackOnKeyInputFocusGained) {
2101     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2102     return;
2103   } else {
2104     swig_callbackOnKeyInputFocusGained();
2105   }
2106 }
2107
2108 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2109   if (!swig_callbackOnKeyInputFocusLost) {
2110     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2111     return;
2112   } else {
2113     swig_callbackOnKeyInputFocusLost();
2114   }
2115 }
2116
2117 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2118   Dali::Actor c_result ;
2119   void * jresult = 0 ;
2120   void * jcurrentFocusedActor  ;
2121   int jdirection  ;
2122   unsigned int jloopEnabled  ;
2123
2124   if (!swig_callbackGetNextKeyboardFocusableActor) {
2125     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2126   } else {
2127     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2128     jdirection = (int)direction;
2129     jloopEnabled = loopEnabled;
2130     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2131     if (!jresult) {
2132       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2133       return c_result;
2134     }
2135     c_result = *(Dali::Actor *)jresult;
2136   }
2137   return c_result;
2138 }
2139
2140 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2141   void * jcommitedFocusableActor  ;
2142
2143   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2144     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2145     return;
2146   } else {
2147     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2148     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2149   }
2150 }
2151
2152 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2153   bool c_result = SwigValueInit< bool >() ;
2154   unsigned int jresult = 0 ;
2155
2156   if (!swig_callbackOnKeyboardEnter) {
2157     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2158   } else {
2159     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2160     c_result = jresult ? true : false;
2161   }
2162   return c_result;
2163 }
2164
2165 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2166   void * jpinch = 0 ;
2167
2168   if (!swig_callbackOnPinch) {
2169     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2170     return;
2171   } else {
2172     jpinch = (Dali::PinchGesture *) &pinch;
2173     swig_callbackOnPinch(jpinch);
2174   }
2175 }
2176
2177 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2178   void * jpan = 0 ;
2179
2180   if (!swig_callbackOnPan) {
2181     Dali::Toolkit::Internal::Control::OnPan(pan);
2182     return;
2183   } else {
2184     jpan = (Dali::PanGesture *) &pan;
2185     swig_callbackOnPan(jpan);
2186   }
2187 }
2188
2189 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2190   void * jtap = 0 ;
2191
2192   if (!swig_callbackOnTap) {
2193     Dali::Toolkit::Internal::Control::OnTap(tap);
2194     return;
2195   } else {
2196     jtap = (Dali::TapGesture *) &tap;
2197     swig_callbackOnTap(jtap);
2198   }
2199 }
2200
2201 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2202   void * jlongPress = 0 ;
2203
2204   if (!swig_callbackOnLongPress) {
2205     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2206     return;
2207   } else {
2208     jlongPress = (Dali::LongPressGesture *) &longPress;
2209     swig_callbackOnLongPress(jlongPress);
2210   }
2211 }
2212
2213 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2214   void * jslotObserver = 0 ;
2215   void * jcallback = 0 ;
2216
2217   if (!swig_callbackSignalConnected) {
2218     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2219     return;
2220   } else {
2221     jslotObserver = (void *) slotObserver;
2222     jcallback = (void *) callback;
2223     swig_callbackSignalConnected(jslotObserver, jcallback);
2224   }
2225 }
2226
2227 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2228   void * jslotObserver = 0 ;
2229   void * jcallback = 0 ;
2230
2231   if (!swig_callbackSignalDisconnected) {
2232     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2233     return;
2234   } else {
2235     jslotObserver = (void *) slotObserver;
2236     jcallback = (void *) callback;
2237     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2238   }
2239 }
2240
2241 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2242   return Dali::Toolkit::Internal::Control::GetControlExtension();
2243 }
2244
2245 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) {
2246   swig_callbackOnStageConnection = callbackOnStageConnection;
2247   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2248   swig_callbackOnChildAdd = callbackOnChildAdd;
2249   swig_callbackOnChildRemove = callbackOnChildRemove;
2250   swig_callbackOnPropertySet = callbackOnPropertySet;
2251   swig_callbackOnSizeSet = callbackOnSizeSet;
2252   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2253   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2254   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2255   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2256   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2257   swig_callbackOnRelayout = callbackOnRelayout;
2258   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2259   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2260   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2261   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2262   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2263   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2264   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2265   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2266   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2267   swig_callbackOnInitialize = callbackOnInitialize;
2268   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2269   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2270   swig_callbackOnStyleChange = callbackOnStyleChange;
2271   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2272   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2273   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2274   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2275   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2276   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2277   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2278   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2279   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2280   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2281   swig_callbackOnPinch = callbackOnPinch;
2282   swig_callbackOnPan = callbackOnPan;
2283   swig_callbackOnTap = callbackOnTap;
2284   swig_callbackOnLongPress = callbackOnLongPress;
2285   swig_callbackSignalConnected = callbackSignalConnected;
2286   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2287 }
2288
2289 void SwigDirector_ViewImpl::swig_init_callbacks() {
2290   swig_callbackOnStageConnection = 0;
2291   swig_callbackOnStageDisconnection = 0;
2292   swig_callbackOnChildAdd = 0;
2293   swig_callbackOnChildRemove = 0;
2294   swig_callbackOnPropertySet = 0;
2295   swig_callbackOnSizeSet = 0;
2296   swig_callbackOnSizeAnimation = 0;
2297   swig_callbackOnTouchEvent = 0;
2298   swig_callbackOnHoverEvent = 0;
2299   swig_callbackOnKeyEvent = 0;
2300   swig_callbackOnWheelEvent = 0;
2301   swig_callbackOnRelayout = 0;
2302   swig_callbackOnSetResizePolicy = 0;
2303   swig_callbackGetNaturalSize = 0;
2304   swig_callbackCalculateChildSize = 0;
2305   swig_callbackGetHeightForWidth = 0;
2306   swig_callbackGetWidthForHeight = 0;
2307   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2308   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2309   swig_callbackOnCalculateRelayoutSize = 0;
2310   swig_callbackOnLayoutNegotiated = 0;
2311   swig_callbackOnInitialize = 0;
2312   swig_callbackOnControlChildAdd = 0;
2313   swig_callbackOnControlChildRemove = 0;
2314   swig_callbackOnStyleChange = 0;
2315   swig_callbackOnAccessibilityActivated = 0;
2316   swig_callbackOnAccessibilityPan = 0;
2317   swig_callbackOnAccessibilityTouch = 0;
2318   swig_callbackOnAccessibilityValueChange = 0;
2319   swig_callbackOnAccessibilityZoom = 0;
2320   swig_callbackOnKeyInputFocusGained = 0;
2321   swig_callbackOnKeyInputFocusLost = 0;
2322   swig_callbackGetNextKeyboardFocusableActor = 0;
2323   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2324   swig_callbackOnKeyboardEnter = 0;
2325   swig_callbackOnPinch = 0;
2326   swig_callbackOnPan = 0;
2327   swig_callbackOnTap = 0;
2328   swig_callbackOnLongPress = 0;
2329   swig_callbackSignalConnected = 0;
2330   swig_callbackSignalDisconnected = 0;
2331 }
2332
2333 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2334   swig_init_callbacks();
2335 }
2336
2337 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2338
2339 }
2340
2341
2342 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2343   unsigned int c_result = SwigValueInit< unsigned int >() ;
2344   unsigned int jresult = 0 ;
2345
2346   if (!swig_callbackGetNumberOfItems) {
2347     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2348   } else {
2349     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2350     c_result = (unsigned int)jresult;
2351   }
2352   return c_result;
2353 }
2354
2355 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2356   Dali::Actor c_result ;
2357   void * jresult = 0 ;
2358   unsigned int jitemId  ;
2359
2360   if (!swig_callbackNewItem) {
2361     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2362   } else {
2363     jitemId = itemId;
2364     jresult = (void *) swig_callbackNewItem(jitemId);
2365     if (!jresult) {
2366       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2367       return c_result;
2368     }
2369     c_result = *(Dali::Actor *)jresult;
2370   }
2371   return c_result;
2372 }
2373
2374 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2375   unsigned int jitemId  ;
2376   void * jactor  ;
2377
2378   if (!swig_callbackItemReleased) {
2379     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2380     return;
2381   } else {
2382     jitemId = itemId;
2383     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2384     swig_callbackItemReleased(jitemId, jactor);
2385   }
2386 }
2387
2388 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2389   return Dali::Toolkit::ItemFactory::GetExtension();
2390 }
2391
2392 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2393   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2394   swig_callbackNewItem = callbackNewItem;
2395   swig_callbackItemReleased = callbackItemReleased;
2396 }
2397
2398 void SwigDirector_ItemFactory::swig_init_callbacks() {
2399   swig_callbackGetNumberOfItems = 0;
2400   swig_callbackNewItem = 0;
2401   swig_callbackItemReleased = 0;
2402 }
2403
2404 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2405   swig_init_callbacks();
2406 }
2407
2408 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2409
2410 }
2411
2412
2413 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2414   Dali::Actor c_result ;
2415   void * jresult = 0 ;
2416   void * jcurrent  ;
2417   void * jproposed  ;
2418   int jdirection  ;
2419
2420   if (!swig_callbackGetNextFocusableActor) {
2421     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2422   } else {
2423     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2424     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2425     jdirection = (int)direction;
2426     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2427     if (!jresult) {
2428       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2429       return c_result;
2430     }
2431     c_result = *(Dali::Actor *)jresult;
2432   }
2433   return c_result;
2434 }
2435
2436 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2437   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2438 }
2439
2440 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2441   swig_callbackGetNextFocusableActor = 0;
2442 }
2443
2444
2445 #ifdef __cplusplus
2446 extern "C" {
2447 #endif
2448
2449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2450   void * jresult ;
2451   floatp *result = 0 ;
2452
2453   {
2454     try {
2455       result = (floatp *)new_floatp();
2456     } catch (std::out_of_range& e) {
2457       {
2458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2459       };
2460     } catch (std::exception& e) {
2461       {
2462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2463       };
2464     } catch (DaliException e) {
2465       {
2466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2467       };
2468     } catch (...) {
2469       {
2470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2471       };
2472     }
2473   }
2474   jresult = (void *)result;
2475   return jresult;
2476 }
2477
2478
2479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2480   floatp *arg1 = (floatp *) 0 ;
2481
2482   arg1 = (floatp *)jarg1;
2483   {
2484     try {
2485       delete_floatp(arg1);
2486     } catch (std::out_of_range& e) {
2487       {
2488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2489       };
2490     } catch (std::exception& e) {
2491       {
2492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2493       };
2494     } catch (Dali::DaliException e) {
2495       {
2496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2497       };
2498     } catch (...) {
2499       {
2500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2501       };
2502     }
2503   }
2504
2505 }
2506
2507
2508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2509   floatp *arg1 = (floatp *) 0 ;
2510   float arg2 ;
2511
2512   arg1 = (floatp *)jarg1;
2513   arg2 = (float)jarg2;
2514   {
2515     try {
2516       floatp_assign(arg1,arg2);
2517     } catch (std::out_of_range& e) {
2518       {
2519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2520       };
2521     } catch (std::exception& e) {
2522       {
2523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2524       };
2525     } catch (Dali::DaliException e) {
2526       {
2527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2528       };
2529     } catch (...) {
2530       {
2531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2532       };
2533     }
2534   }
2535
2536 }
2537
2538
2539 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2540   float jresult ;
2541   floatp *arg1 = (floatp *) 0 ;
2542   float result;
2543
2544   arg1 = (floatp *)jarg1;
2545   {
2546     try {
2547       result = (float)floatp_value(arg1);
2548     } catch (std::out_of_range& e) {
2549       {
2550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2551       };
2552     } catch (std::exception& e) {
2553       {
2554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2555       };
2556     } catch (DaliException e) {
2557       {
2558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2559       };
2560     } catch (...) {
2561       {
2562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2563       };
2564     }
2565   }
2566   jresult = result;
2567   return jresult;
2568 }
2569
2570
2571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2572   void * jresult ;
2573   floatp *arg1 = (floatp *) 0 ;
2574   float *result = 0 ;
2575
2576   arg1 = (floatp *)jarg1;
2577   {
2578     try {
2579       result = (float *)floatp_cast(arg1);
2580     } catch (std::out_of_range& e) {
2581       {
2582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2583       };
2584     } catch (std::exception& e) {
2585       {
2586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2587       };
2588     } catch (Dali::DaliException e) {
2589       {
2590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2591       };
2592     } catch (...) {
2593       {
2594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2595       };
2596     }
2597   }
2598
2599   jresult = (void *)result;
2600   return jresult;
2601 }
2602
2603
2604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2605   void * jresult ;
2606   float *arg1 = (float *) 0 ;
2607   floatp *result = 0 ;
2608
2609   arg1 = (float *)jarg1;
2610   {
2611     try {
2612       result = (floatp *)floatp_frompointer(arg1);
2613     } catch (std::out_of_range& e) {
2614       {
2615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2616       };
2617     } catch (std::exception& e) {
2618       {
2619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2620       };
2621     } catch (Dali::DaliException e) {
2622       {
2623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2624       };
2625     } catch (...) {
2626       {
2627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2628       };
2629     }
2630   }
2631
2632   jresult = (void *)result;
2633   return jresult;
2634 }
2635
2636
2637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2638   void * jresult ;
2639   intp *result = 0 ;
2640
2641   {
2642     try {
2643       result = (intp *)new_intp();
2644     } catch (std::out_of_range& e) {
2645       {
2646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2647       };
2648     } catch (std::exception& e) {
2649       {
2650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2651       };
2652     } catch (Dali::DaliException e) {
2653       {
2654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2655       };
2656     } catch (...) {
2657       {
2658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2659       };
2660     }
2661   }
2662
2663   jresult = (void *)result;
2664   return jresult;
2665 }
2666
2667
2668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2669   intp *arg1 = (intp *) 0 ;
2670
2671   arg1 = (intp *)jarg1;
2672   {
2673     try {
2674       delete_intp(arg1);
2675     } catch (std::out_of_range& e) {
2676       {
2677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2678       };
2679     } catch (std::exception& e) {
2680       {
2681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2682       };
2683     } catch (Dali::DaliException e) {
2684       {
2685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2686       };
2687     } catch (...) {
2688       {
2689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2690       };
2691     }
2692   }
2693
2694 }
2695
2696
2697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2698   intp *arg1 = (intp *) 0 ;
2699   int arg2 ;
2700
2701   arg1 = (intp *)jarg1;
2702   arg2 = (int)jarg2;
2703   {
2704     try {
2705       intp_assign(arg1,arg2);
2706     } catch (std::out_of_range& e) {
2707       {
2708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2709       };
2710     } catch (std::exception& e) {
2711       {
2712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2713       };
2714     } catch (Dali::DaliException e) {
2715       {
2716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2717       };
2718     } catch (...) {
2719       {
2720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2721       };
2722     }
2723   }
2724
2725 }
2726
2727
2728 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2729   int jresult ;
2730   intp *arg1 = (intp *) 0 ;
2731   int result;
2732
2733   arg1 = (intp *)jarg1;
2734   {
2735     try {
2736       result = (int)intp_value(arg1);
2737     } catch (std::out_of_range& e) {
2738       {
2739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2740       };
2741     } catch (std::exception& e) {
2742       {
2743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2744       };
2745     } catch (Dali::DaliException e) {
2746       {
2747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2748       };
2749     } catch (...) {
2750       {
2751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2752       };
2753     }
2754   }
2755
2756   jresult = result;
2757   return jresult;
2758 }
2759
2760
2761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2762   void * jresult ;
2763   intp *arg1 = (intp *) 0 ;
2764   int *result = 0 ;
2765
2766   arg1 = (intp *)jarg1;
2767   {
2768     try {
2769       result = (int *)intp_cast(arg1);
2770     } catch (std::out_of_range& e) {
2771       {
2772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2773       };
2774     } catch (std::exception& e) {
2775       {
2776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2777       };
2778     } catch (Dali::DaliException e) {
2779       {
2780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2781       };
2782     } catch (...) {
2783       {
2784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2785       };
2786     }
2787   }
2788
2789   jresult = (void *)result;
2790   return jresult;
2791 }
2792
2793
2794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2795   void * jresult ;
2796   int *arg1 = (int *) 0 ;
2797   intp *result = 0 ;
2798
2799   arg1 = (int *)jarg1;
2800   {
2801     try {
2802       result = (intp *)intp_frompointer(arg1);
2803     } catch (std::out_of_range& e) {
2804       {
2805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2806       };
2807     } catch (std::exception& e) {
2808       {
2809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2810       };
2811     } catch (Dali::DaliException e) {
2812       {
2813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2814       };
2815     } catch (...) {
2816       {
2817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2818       };
2819     }
2820   }
2821
2822   jresult = (void *)result;
2823   return jresult;
2824 }
2825
2826
2827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2828   void * jresult ;
2829   doublep *result = 0 ;
2830
2831   {
2832     try {
2833       result = (doublep *)new_doublep();
2834     } catch (std::out_of_range& e) {
2835       {
2836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2837       };
2838     } catch (std::exception& e) {
2839       {
2840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2841       };
2842     } catch (Dali::DaliException e) {
2843       {
2844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2845       };
2846     } catch (...) {
2847       {
2848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2849       };
2850     }
2851   }
2852
2853   jresult = (void *)result;
2854   return jresult;
2855 }
2856
2857
2858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2859   doublep *arg1 = (doublep *) 0 ;
2860
2861   arg1 = (doublep *)jarg1;
2862   {
2863     try {
2864       delete_doublep(arg1);
2865     } catch (std::out_of_range& e) {
2866       {
2867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2868       };
2869     } catch (std::exception& e) {
2870       {
2871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2872       };
2873     } catch (Dali::DaliException e) {
2874       {
2875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2876       };
2877     } catch (...) {
2878       {
2879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2880       };
2881     }
2882   }
2883
2884 }
2885
2886
2887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2888   doublep *arg1 = (doublep *) 0 ;
2889   double arg2 ;
2890
2891   arg1 = (doublep *)jarg1;
2892   arg2 = (double)jarg2;
2893   {
2894     try {
2895       doublep_assign(arg1,arg2);
2896     } catch (std::out_of_range& e) {
2897       {
2898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2899       };
2900     } catch (std::exception& e) {
2901       {
2902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2903       };
2904     } catch (Dali::DaliException e) {
2905       {
2906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2907       };
2908     } catch (...) {
2909       {
2910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2911       };
2912     }
2913   }
2914
2915 }
2916
2917
2918 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
2919   double jresult ;
2920   doublep *arg1 = (doublep *) 0 ;
2921   double result;
2922
2923   arg1 = (doublep *)jarg1;
2924   {
2925     try {
2926       result = (double)doublep_value(arg1);
2927     } catch (std::out_of_range& e) {
2928       {
2929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2930       };
2931     } catch (std::exception& e) {
2932       {
2933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2934       };
2935     } catch (Dali::DaliException e) {
2936       {
2937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2938       };
2939     } catch (...) {
2940       {
2941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2942       };
2943     }
2944   }
2945
2946   jresult = result;
2947   return jresult;
2948 }
2949
2950
2951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
2952   void * jresult ;
2953   doublep *arg1 = (doublep *) 0 ;
2954   double *result = 0 ;
2955
2956   arg1 = (doublep *)jarg1;
2957   {
2958     try {
2959       result = (double *)doublep_cast(arg1);
2960     } catch (std::out_of_range& e) {
2961       {
2962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2963       };
2964     } catch (std::exception& e) {
2965       {
2966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2967       };
2968     } catch (Dali::DaliException e) {
2969       {
2970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2971       };
2972     } catch (...) {
2973       {
2974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2975       };
2976     }
2977   }
2978
2979   jresult = (void *)result;
2980   return jresult;
2981 }
2982
2983
2984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
2985   void * jresult ;
2986   double *arg1 = (double *) 0 ;
2987   doublep *result = 0 ;
2988
2989   arg1 = (double *)jarg1;
2990   {
2991     try {
2992       result = (doublep *)doublep_frompointer(arg1);
2993     } catch (std::out_of_range& e) {
2994       {
2995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2996       };
2997     } catch (std::exception& e) {
2998       {
2999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3000       };
3001     } catch (Dali::DaliException e) {
3002       {
3003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3004       };
3005     } catch (...) {
3006       {
3007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3008       };
3009     }
3010   }
3011
3012   jresult = (void *)result;
3013   return jresult;
3014 }
3015
3016
3017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
3018   void * jresult ;
3019   uintp *result = 0 ;
3020
3021   {
3022     try {
3023       result = (uintp *)new_uintp();
3024     } catch (std::out_of_range& e) {
3025       {
3026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3027       };
3028     } catch (std::exception& e) {
3029       {
3030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3031       };
3032     } catch (Dali::DaliException e) {
3033       {
3034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3035       };
3036     } catch (...) {
3037       {
3038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3039       };
3040     }
3041   }
3042
3043   jresult = (void *)result;
3044   return jresult;
3045 }
3046
3047
3048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
3049   uintp *arg1 = (uintp *) 0 ;
3050
3051   arg1 = (uintp *)jarg1;
3052   {
3053     try {
3054       delete_uintp(arg1);
3055     } catch (std::out_of_range& e) {
3056       {
3057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3058       };
3059     } catch (std::exception& e) {
3060       {
3061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3062       };
3063     } catch (Dali::DaliException e) {
3064       {
3065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3066       };
3067     } catch (...) {
3068       {
3069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3070       };
3071     }
3072   }
3073
3074 }
3075
3076
3077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3078   uintp *arg1 = (uintp *) 0 ;
3079   unsigned int arg2 ;
3080
3081   arg1 = (uintp *)jarg1;
3082   arg2 = (unsigned int)jarg2;
3083   {
3084     try {
3085       uintp_assign(arg1,arg2);
3086     } catch (std::out_of_range& e) {
3087       {
3088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3089       };
3090     } catch (std::exception& e) {
3091       {
3092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3093       };
3094     } catch (Dali::DaliException e) {
3095       {
3096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3097       };
3098     } catch (...) {
3099       {
3100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3101       };
3102     }
3103   }
3104
3105 }
3106
3107
3108 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3109   unsigned int jresult ;
3110   uintp *arg1 = (uintp *) 0 ;
3111   unsigned int result;
3112
3113   arg1 = (uintp *)jarg1;
3114   {
3115     try {
3116       result = (unsigned int)uintp_value(arg1);
3117     } catch (std::out_of_range& e) {
3118       {
3119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3120       };
3121     } catch (std::exception& e) {
3122       {
3123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3124       };
3125     } catch (Dali::DaliException e) {
3126       {
3127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3128       };
3129     } catch (...) {
3130       {
3131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3132       };
3133     }
3134   }
3135
3136   jresult = result;
3137   return jresult;
3138 }
3139
3140
3141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3142   void * jresult ;
3143   uintp *arg1 = (uintp *) 0 ;
3144   unsigned int *result = 0 ;
3145
3146   arg1 = (uintp *)jarg1;
3147   {
3148     try {
3149       result = (unsigned int *)uintp_cast(arg1);
3150     } catch (std::out_of_range& e) {
3151       {
3152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3153       };
3154     } catch (std::exception& e) {
3155       {
3156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3157       };
3158     } catch (Dali::DaliException e) {
3159       {
3160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3161       };
3162     } catch (...) {
3163       {
3164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3165       };
3166     }
3167   }
3168
3169   jresult = (void *)result;
3170   return jresult;
3171 }
3172
3173
3174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3175   void * jresult ;
3176   unsigned int *arg1 = (unsigned int *) 0 ;
3177   uintp *result = 0 ;
3178
3179   arg1 = (unsigned int *)jarg1;
3180   {
3181     try {
3182       result = (uintp *)uintp_frompointer(arg1);
3183     } catch (std::out_of_range& e) {
3184       {
3185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3186       };
3187     } catch (std::exception& e) {
3188       {
3189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3190       };
3191     } catch (Dali::DaliException e) {
3192       {
3193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3194       };
3195     } catch (...) {
3196       {
3197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3198       };
3199     }
3200   }
3201
3202   jresult = (void *)result;
3203   return jresult;
3204 }
3205
3206
3207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3208   void * jresult ;
3209   ushortp *result = 0 ;
3210
3211   {
3212     try {
3213       result = (ushortp *)new_ushortp();
3214     } catch (std::out_of_range& e) {
3215       {
3216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3217       };
3218     } catch (std::exception& e) {
3219       {
3220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3221       };
3222     } catch (Dali::DaliException e) {
3223       {
3224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3225       };
3226     } catch (...) {
3227       {
3228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3229       };
3230     }
3231   }
3232
3233   jresult = (void *)result;
3234   return jresult;
3235 }
3236
3237
3238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3239   ushortp *arg1 = (ushortp *) 0 ;
3240
3241   arg1 = (ushortp *)jarg1;
3242   {
3243     try {
3244       delete_ushortp(arg1);
3245     } catch (std::out_of_range& e) {
3246       {
3247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3248       };
3249     } catch (std::exception& e) {
3250       {
3251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3252       };
3253     } catch (Dali::DaliException e) {
3254       {
3255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3256       };
3257     } catch (...) {
3258       {
3259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3260       };
3261     }
3262   }
3263
3264 }
3265
3266
3267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3268   ushortp *arg1 = (ushortp *) 0 ;
3269   unsigned short arg2 ;
3270
3271   arg1 = (ushortp *)jarg1;
3272   arg2 = (unsigned short)jarg2;
3273   {
3274     try {
3275       ushortp_assign(arg1,arg2);
3276     } catch (std::out_of_range& e) {
3277       {
3278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3279       };
3280     } catch (std::exception& e) {
3281       {
3282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3283       };
3284     } catch (Dali::DaliException e) {
3285       {
3286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3287       };
3288     } catch (...) {
3289       {
3290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3291       };
3292     }
3293   }
3294
3295 }
3296
3297
3298 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3299   unsigned short jresult ;
3300   ushortp *arg1 = (ushortp *) 0 ;
3301   unsigned short result;
3302
3303   arg1 = (ushortp *)jarg1;
3304   {
3305     try {
3306       result = (unsigned short)ushortp_value(arg1);
3307     } catch (std::out_of_range& e) {
3308       {
3309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3310       };
3311     } catch (std::exception& e) {
3312       {
3313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3314       };
3315     } catch (Dali::DaliException e) {
3316       {
3317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3318       };
3319     } catch (...) {
3320       {
3321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3322       };
3323     }
3324   }
3325
3326   jresult = result;
3327   return jresult;
3328 }
3329
3330
3331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3332   void * jresult ;
3333   ushortp *arg1 = (ushortp *) 0 ;
3334   unsigned short *result = 0 ;
3335
3336   arg1 = (ushortp *)jarg1;
3337   {
3338     try {
3339       result = (unsigned short *)ushortp_cast(arg1);
3340     } catch (std::out_of_range& e) {
3341       {
3342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3343       };
3344     } catch (std::exception& e) {
3345       {
3346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3347       };
3348     } catch (Dali::DaliException e) {
3349       {
3350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3351       };
3352     } catch (...) {
3353       {
3354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3355       };
3356     }
3357   }
3358
3359   jresult = (void *)result;
3360   return jresult;
3361 }
3362
3363
3364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3365   void * jresult ;
3366   unsigned short *arg1 = (unsigned short *) 0 ;
3367   ushortp *result = 0 ;
3368
3369   arg1 = (unsigned short *)jarg1;
3370   {
3371     try {
3372       result = (ushortp *)ushortp_frompointer(arg1);
3373     } catch (std::out_of_range& e) {
3374       {
3375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3376       };
3377     } catch (std::exception& e) {
3378       {
3379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3380       };
3381     } catch (Dali::DaliException e) {
3382       {
3383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3384       };
3385     } catch (...) {
3386       {
3387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3388       };
3389     }
3390   }
3391
3392   jresult = (void *)result;
3393   return jresult;
3394 }
3395
3396
3397 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3398   unsigned int jresult ;
3399   int arg1 ;
3400   unsigned int result;
3401
3402   arg1 = (int)jarg1;
3403   {
3404     try {
3405       result = (unsigned int)int_to_uint(arg1);
3406     } catch (std::out_of_range& e) {
3407       {
3408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3409       };
3410     } catch (std::exception& e) {
3411       {
3412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3413       };
3414     } catch (Dali::DaliException e) {
3415       {
3416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3417       };
3418     } catch (...) {
3419       {
3420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3421       };
3422     }
3423   }
3424
3425   jresult = result;
3426   return jresult;
3427 }
3428
3429
3430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3431   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3432
3433   arg1 = (Dali::RefObject *)jarg1;
3434   {
3435     try {
3436       (arg1)->Reference();
3437     } catch (std::out_of_range& e) {
3438       {
3439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3440       };
3441     } catch (std::exception& e) {
3442       {
3443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3444       };
3445     } catch (Dali::DaliException e) {
3446       {
3447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3448       };
3449     } catch (...) {
3450       {
3451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3452       };
3453     }
3454   }
3455
3456 }
3457
3458
3459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3460   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3461
3462   arg1 = (Dali::RefObject *)jarg1;
3463   {
3464     try {
3465       (arg1)->Unreference();
3466     } catch (std::out_of_range& e) {
3467       {
3468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3469       };
3470     } catch (std::exception& e) {
3471       {
3472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3473       };
3474     } catch (Dali::DaliException e) {
3475       {
3476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3477       };
3478     } catch (...) {
3479       {
3480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3481       };
3482     }
3483   }
3484
3485 }
3486
3487
3488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3489   int jresult ;
3490   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3491   int result;
3492
3493   arg1 = (Dali::RefObject *)jarg1;
3494   {
3495     try {
3496       result = (int)(arg1)->ReferenceCount();
3497     } catch (std::out_of_range& e) {
3498       {
3499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3500       };
3501     } catch (std::exception& e) {
3502       {
3503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3504       };
3505     } catch (Dali::DaliException e) {
3506       {
3507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3508       };
3509     } catch (...) {
3510       {
3511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3512       };
3513     }
3514   }
3515
3516   jresult = result;
3517   return jresult;
3518 }
3519
3520
3521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3522   void * jresult ;
3523   Dali::Any *result = 0 ;
3524
3525   {
3526     try {
3527       result = (Dali::Any *)new Dali::Any();
3528     } catch (std::out_of_range& e) {
3529       {
3530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3531       };
3532     } catch (std::exception& e) {
3533       {
3534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3535       };
3536     } catch (Dali::DaliException e) {
3537       {
3538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3539       };
3540     } catch (...) {
3541       {
3542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3543       };
3544     }
3545   }
3546
3547   jresult = (void *)result;
3548   return jresult;
3549 }
3550
3551
3552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3553   Dali::Any *arg1 = (Dali::Any *) 0 ;
3554
3555   arg1 = (Dali::Any *)jarg1;
3556   {
3557     try {
3558       delete arg1;
3559     } catch (std::out_of_range& e) {
3560       {
3561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3562       };
3563     } catch (std::exception& e) {
3564       {
3565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3566       };
3567     } catch (Dali::DaliException e) {
3568       {
3569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3570       };
3571     } catch (...) {
3572       {
3573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3574       };
3575     }
3576   }
3577
3578 }
3579
3580
3581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3582   char *arg1 = (char *) 0 ;
3583
3584   arg1 = (char *)jarg1;
3585   {
3586     try {
3587       Dali::Any::AssertAlways((char const *)arg1);
3588     } catch (std::out_of_range& e) {
3589       {
3590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3591       };
3592     } catch (std::exception& e) {
3593       {
3594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3595       };
3596     } catch (Dali::DaliException e) {
3597       {
3598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3599       };
3600     } catch (...) {
3601       {
3602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3603       };
3604     }
3605   }
3606
3607 }
3608
3609
3610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3611   void * jresult ;
3612   Dali::Any *arg1 = 0 ;
3613   Dali::Any *result = 0 ;
3614
3615   arg1 = (Dali::Any *)jarg1;
3616   if (!arg1) {
3617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3618     return 0;
3619   }
3620   {
3621     try {
3622       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3623     } catch (std::out_of_range& e) {
3624       {
3625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3626       };
3627     } catch (std::exception& e) {
3628       {
3629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3630       };
3631     } catch (Dali::DaliException e) {
3632       {
3633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3634       };
3635     } catch (...) {
3636       {
3637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3638       };
3639     }
3640   }
3641
3642   jresult = (void *)result;
3643   return jresult;
3644 }
3645
3646
3647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3648   void * jresult ;
3649   Dali::Any *arg1 = (Dali::Any *) 0 ;
3650   Dali::Any *arg2 = 0 ;
3651   Dali::Any *result = 0 ;
3652
3653   arg1 = (Dali::Any *)jarg1;
3654   arg2 = (Dali::Any *)jarg2;
3655   if (!arg2) {
3656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3657     return 0;
3658   }
3659   {
3660     try {
3661       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3662     } catch (std::out_of_range& e) {
3663       {
3664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3665       };
3666     } catch (std::exception& e) {
3667       {
3668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3669       };
3670     } catch (Dali::DaliException e) {
3671       {
3672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3673       };
3674     } catch (...) {
3675       {
3676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3677       };
3678     }
3679   }
3680
3681   jresult = (void *)result;
3682   return jresult;
3683 }
3684
3685
3686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3687   void * jresult ;
3688   Dali::Any *arg1 = (Dali::Any *) 0 ;
3689   std::type_info *result = 0 ;
3690
3691   arg1 = (Dali::Any *)jarg1;
3692   {
3693     try {
3694       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3695     } catch (std::out_of_range& e) {
3696       {
3697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3698       };
3699     } catch (std::exception& e) {
3700       {
3701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3702       };
3703     } catch (Dali::DaliException e) {
3704       {
3705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3706       };
3707     } catch (...) {
3708       {
3709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3710       };
3711     }
3712   }
3713
3714   jresult = (void *)result;
3715   return jresult;
3716 }
3717
3718
3719 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3720   unsigned int jresult ;
3721   Dali::Any *arg1 = (Dali::Any *) 0 ;
3722   bool result;
3723
3724   arg1 = (Dali::Any *)jarg1;
3725   {
3726     try {
3727       result = (bool)((Dali::Any const *)arg1)->Empty();
3728     } catch (std::out_of_range& e) {
3729       {
3730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3731       };
3732     } catch (std::exception& e) {
3733       {
3734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3735       };
3736     } catch (Dali::DaliException e) {
3737       {
3738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3739       };
3740     } catch (...) {
3741       {
3742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3743       };
3744     }
3745   }
3746
3747   jresult = result;
3748   return jresult;
3749 }
3750
3751
3752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3753   void * jresult ;
3754   std::type_info *arg1 = 0 ;
3755   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3756   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3757   Dali::Any::AnyContainerBase *result = 0 ;
3758
3759   arg1 = (std::type_info *)jarg1;
3760   if (!arg1) {
3761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3762     return 0;
3763   }
3764   arg2 = (Dali::Any::CloneFunc)jarg2;
3765   arg3 = (Dali::Any::DeleteFunc)jarg3;
3766   {
3767     try {
3768       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3769     } catch (std::out_of_range& e) {
3770       {
3771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3772       };
3773     } catch (std::exception& e) {
3774       {
3775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3776       };
3777     } catch (Dali::DaliException e) {
3778       {
3779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3780       };
3781     } catch (...) {
3782       {
3783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3784       };
3785     }
3786   }
3787
3788   jresult = (void *)result;
3789   return jresult;
3790 }
3791
3792
3793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3794   void * jresult ;
3795   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3796   std::type_info *result = 0 ;
3797
3798   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3799   {
3800     try {
3801       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3802     } catch (std::out_of_range& e) {
3803       {
3804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3805       };
3806     } catch (std::exception& e) {
3807       {
3808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3809       };
3810     } catch (Dali::DaliException e) {
3811       {
3812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3813       };
3814     } catch (...) {
3815       {
3816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3817       };
3818     }
3819   }
3820
3821   jresult = (void *)result;
3822   return jresult;
3823 }
3824
3825
3826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3827   void * jresult ;
3828   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3829   ::std::type_info *result = 0 ;
3830
3831   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3832   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3833   jresult = (void *)result;
3834   return jresult;
3835 }
3836
3837
3838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3839   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3840   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3841
3842   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3843   arg2 = (Dali::Any::CloneFunc)jarg2;
3844   if (arg1) (arg1)->mCloneFunc = arg2;
3845 }
3846
3847
3848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3849   void * jresult ;
3850   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3851   Dali::Any::CloneFunc result;
3852
3853   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3854   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3855   jresult = (void *)result;
3856   return jresult;
3857 }
3858
3859
3860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3861   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3862   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3863
3864   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3865   arg2 = (Dali::Any::DeleteFunc)jarg2;
3866   if (arg1) (arg1)->mDeleteFunc = arg2;
3867 }
3868
3869
3870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
3871   void * jresult ;
3872   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3873   Dali::Any::DeleteFunc result;
3874
3875   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3876   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
3877   jresult = (void *)result;
3878   return jresult;
3879 }
3880
3881
3882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
3883   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3884
3885   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3886   {
3887     try {
3888       delete arg1;
3889     } catch (std::out_of_range& e) {
3890       {
3891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3892       };
3893     } catch (std::exception& e) {
3894       {
3895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3896       };
3897     } catch (Dali::DaliException e) {
3898       {
3899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3900       };
3901     } catch (...) {
3902       {
3903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3904       };
3905     }
3906   }
3907
3908 }
3909
3910
3911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
3912   Dali::Any *arg1 = (Dali::Any *) 0 ;
3913   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
3914
3915   arg1 = (Dali::Any *)jarg1;
3916   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
3917   if (arg1) (arg1)->mContainer = arg2;
3918 }
3919
3920
3921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
3922   void * jresult ;
3923   Dali::Any *arg1 = (Dali::Any *) 0 ;
3924   Dali::Any::AnyContainerBase *result = 0 ;
3925
3926   arg1 = (Dali::Any *)jarg1;
3927   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
3928   jresult = (void *)result;
3929   return jresult;
3930 }
3931
3932
3933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
3934   char *arg1 = (char *) 0 ;
3935   char *arg2 = (char *) 0 ;
3936
3937   arg1 = (char *)jarg1;
3938   arg2 = (char *)jarg2;
3939   {
3940     try {
3941       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
3942     } catch (std::out_of_range& e) {
3943       {
3944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3945       };
3946     } catch (std::exception& e) {
3947       {
3948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3949       };
3950     } catch (Dali::DaliException e) {
3951       {
3952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3953       };
3954     } catch (...) {
3955       {
3956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3957       };
3958     }
3959   }
3960
3961 }
3962
3963
3964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
3965   void * jresult ;
3966   char *arg1 = (char *) 0 ;
3967   char *arg2 = (char *) 0 ;
3968   Dali::DaliException *result = 0 ;
3969
3970   arg1 = (char *)jarg1;
3971   arg2 = (char *)jarg2;
3972   {
3973     try {
3974       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
3975     } catch (std::out_of_range& e) {
3976       {
3977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3978       };
3979     } catch (std::exception& e) {
3980       {
3981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3982       };
3983     } catch (Dali::DaliException e) {
3984       {
3985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3986       };
3987     } catch (...) {
3988       {
3989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3990       };
3991     }
3992   }
3993
3994   jresult = (void *)result;
3995   return jresult;
3996 }
3997
3998
3999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
4000   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4001   std::string arg2 = std::string(jarg2);
4002
4003   arg1 = (Dali::DaliException *)jarg1;
4004   {
4005     if (!arg2.empty()) {
4006       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
4007     } else {
4008       arg1->location = 0;
4009     }
4010   }
4011 }
4012
4013 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
4014   char * jresult ;
4015   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4016   char *result = 0 ;
4017
4018   arg1 = (Dali::DaliException *)jarg1;
4019   result = (char *) ((arg1)->location);
4020   jresult = SWIG_csharp_string_callback((const char *)result);
4021   return jresult;
4022 }
4023
4024
4025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
4026   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4027   std::string arg2 = std::string(jarg2);
4028
4029   arg1 = (Dali::DaliException *)jarg1;
4030   {
4031     if (!arg2.empty()) {
4032       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
4033     } else {
4034       arg1->condition = 0;
4035     }
4036   }
4037 }
4038
4039
4040 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
4041   char * jresult ;
4042   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4043   char *result = 0 ;
4044
4045   arg1 = (Dali::DaliException *)jarg1;
4046   result = (char *) ((arg1)->condition);
4047   jresult = SWIG_csharp_string_callback((const char *)result);
4048   return jresult;
4049 }
4050
4051
4052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
4053   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4054
4055   arg1 = (Dali::DaliException *)jarg1;
4056   {
4057     try {
4058       delete arg1;
4059     } catch (std::out_of_range& e) {
4060       {
4061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4062       };
4063     } catch (std::exception& e) {
4064       {
4065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4066       };
4067     } catch (Dali::DaliException e) {
4068       {
4069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4070       };
4071     } catch (...) {
4072       {
4073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4074       };
4075     }
4076   }
4077
4078 }
4079
4080
4081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
4082   void * jresult ;
4083   Dali::Vector2 *result = 0 ;
4084
4085   {
4086     try {
4087       result = (Dali::Vector2 *)new Dali::Vector2();
4088     } catch (std::out_of_range& e) {
4089       {
4090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4091       };
4092     } catch (std::exception& e) {
4093       {
4094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4095       };
4096     } catch (Dali::DaliException e) {
4097       {
4098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4099       };
4100     } catch (...) {
4101       {
4102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4103       };
4104     }
4105   }
4106
4107   jresult = (void *)result;
4108   return jresult;
4109 }
4110
4111
4112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
4113   void * jresult ;
4114   float arg1 ;
4115   float arg2 ;
4116   Dali::Vector2 *result = 0 ;
4117
4118   arg1 = (float)jarg1;
4119   arg2 = (float)jarg2;
4120   {
4121     try {
4122       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
4123     } catch (std::out_of_range& e) {
4124       {
4125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4126       };
4127     } catch (std::exception& e) {
4128       {
4129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4130       };
4131     } catch (Dali::DaliException e) {
4132       {
4133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4134       };
4135     } catch (...) {
4136       {
4137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4138       };
4139     }
4140   }
4141
4142   jresult = (void *)result;
4143   return jresult;
4144 }
4145
4146
4147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
4148   void * jresult ;
4149   float *arg1 = (float *) 0 ;
4150   Dali::Vector2 *result = 0 ;
4151
4152   arg1 = jarg1;
4153   {
4154     try {
4155       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
4156     } catch (std::out_of_range& e) {
4157       {
4158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4159       };
4160     } catch (std::exception& e) {
4161       {
4162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4163       };
4164     } catch (Dali::DaliException e) {
4165       {
4166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4167       };
4168     } catch (...) {
4169       {
4170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4171       };
4172     }
4173   }
4174
4175   jresult = (void *)result;
4176
4177
4178   return jresult;
4179 }
4180
4181
4182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
4183   void * jresult ;
4184   Dali::Vector3 *arg1 = 0 ;
4185   Dali::Vector2 *result = 0 ;
4186
4187   arg1 = (Dali::Vector3 *)jarg1;
4188   if (!arg1) {
4189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4190     return 0;
4191   }
4192   {
4193     try {
4194       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
4195     } catch (std::out_of_range& e) {
4196       {
4197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4198       };
4199     } catch (std::exception& e) {
4200       {
4201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4202       };
4203     } catch (Dali::DaliException e) {
4204       {
4205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4206       };
4207     } catch (...) {
4208       {
4209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4210       };
4211     }
4212   }
4213
4214   jresult = (void *)result;
4215   return jresult;
4216 }
4217
4218
4219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4220   void * jresult ;
4221   Dali::Vector4 *arg1 = 0 ;
4222   Dali::Vector2 *result = 0 ;
4223
4224   arg1 = (Dali::Vector4 *)jarg1;
4225   if (!arg1) {
4226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4227     return 0;
4228   }
4229   {
4230     try {
4231       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4232     } catch (std::out_of_range& e) {
4233       {
4234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4235       };
4236     } catch (std::exception& e) {
4237       {
4238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4239       };
4240     } catch (Dali::DaliException e) {
4241       {
4242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4243       };
4244     } catch (...) {
4245       {
4246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4247       };
4248     }
4249   }
4250
4251   jresult = (void *)result;
4252   return jresult;
4253 }
4254
4255
4256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4257   void * jresult ;
4258   Dali::Vector2 *result = 0 ;
4259
4260   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4261   jresult = (void *)result;
4262   return jresult;
4263 }
4264
4265
4266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4267   void * jresult ;
4268   Dali::Vector2 *result = 0 ;
4269
4270   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4271   jresult = (void *)result;
4272   return jresult;
4273 }
4274
4275
4276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4277   void * jresult ;
4278   Dali::Vector2 *result = 0 ;
4279
4280   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4281   jresult = (void *)result;
4282   return jresult;
4283 }
4284
4285
4286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4287   void * jresult ;
4288   Dali::Vector2 *result = 0 ;
4289
4290   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4291   jresult = (void *)result;
4292   return jresult;
4293 }
4294
4295
4296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4297   void * jresult ;
4298   Dali::Vector2 *result = 0 ;
4299
4300   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4301   jresult = (void *)result;
4302   return jresult;
4303 }
4304
4305
4306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4307   void * jresult ;
4308   Dali::Vector2 *result = 0 ;
4309
4310   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4311   jresult = (void *)result;
4312   return jresult;
4313 }
4314
4315
4316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4317   void * jresult ;
4318   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4319   float *arg2 = (float *) 0 ;
4320   Dali::Vector2 *result = 0 ;
4321
4322   arg1 = (Dali::Vector2 *)jarg1;
4323   arg2 = jarg2;
4324   {
4325     try {
4326       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4327     } catch (std::out_of_range& e) {
4328       {
4329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4330       };
4331     } catch (std::exception& e) {
4332       {
4333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4334       };
4335     } catch (Dali::DaliException e) {
4336       {
4337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4338       };
4339     } catch (...) {
4340       {
4341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4342       };
4343     }
4344   }
4345
4346   jresult = (void *)result;
4347
4348
4349   return jresult;
4350 }
4351
4352
4353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4354   void * jresult ;
4355   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4356   Dali::Vector3 *arg2 = 0 ;
4357   Dali::Vector2 *result = 0 ;
4358
4359   arg1 = (Dali::Vector2 *)jarg1;
4360   arg2 = (Dali::Vector3 *)jarg2;
4361   if (!arg2) {
4362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4363     return 0;
4364   }
4365   {
4366     try {
4367       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4368     } catch (std::out_of_range& e) {
4369       {
4370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4371       };
4372     } catch (std::exception& e) {
4373       {
4374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4375       };
4376     } catch (Dali::DaliException e) {
4377       {
4378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4379       };
4380     } catch (...) {
4381       {
4382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4383       };
4384     }
4385   }
4386
4387   jresult = (void *)result;
4388   return jresult;
4389 }
4390
4391
4392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4393   void * jresult ;
4394   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4395   Dali::Vector4 *arg2 = 0 ;
4396   Dali::Vector2 *result = 0 ;
4397
4398   arg1 = (Dali::Vector2 *)jarg1;
4399   arg2 = (Dali::Vector4 *)jarg2;
4400   if (!arg2) {
4401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4402     return 0;
4403   }
4404   {
4405     try {
4406       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4407     } catch (std::out_of_range& e) {
4408       {
4409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4410       };
4411     } catch (std::exception& e) {
4412       {
4413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4414       };
4415     } catch (Dali::DaliException e) {
4416       {
4417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4418       };
4419     } catch (...) {
4420       {
4421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4422       };
4423     }
4424   }
4425
4426   jresult = (void *)result;
4427   return jresult;
4428 }
4429
4430
4431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4432   void * jresult ;
4433   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4434   Dali::Vector2 *arg2 = 0 ;
4435   Dali::Vector2 result;
4436
4437   arg1 = (Dali::Vector2 *)jarg1;
4438   arg2 = (Dali::Vector2 *)jarg2;
4439   if (!arg2) {
4440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4441     return 0;
4442   }
4443   {
4444     try {
4445       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4446     } catch (std::out_of_range& e) {
4447       {
4448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4449       };
4450     } catch (std::exception& e) {
4451       {
4452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4453       };
4454     } catch (Dali::DaliException e) {
4455       {
4456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4457       };
4458     } catch (...) {
4459       {
4460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4461       };
4462     }
4463   }
4464
4465   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4466   return jresult;
4467 }
4468
4469
4470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4471   void * jresult ;
4472   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4473   Dali::Vector2 *arg2 = 0 ;
4474   Dali::Vector2 *result = 0 ;
4475
4476   arg1 = (Dali::Vector2 *)jarg1;
4477   arg2 = (Dali::Vector2 *)jarg2;
4478   if (!arg2) {
4479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4480     return 0;
4481   }
4482   {
4483     try {
4484       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4485     } catch (std::out_of_range& e) {
4486       {
4487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4488       };
4489     } catch (std::exception& e) {
4490       {
4491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4492       };
4493     } catch (Dali::DaliException e) {
4494       {
4495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4496       };
4497     } catch (...) {
4498       {
4499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4500       };
4501     }
4502   }
4503
4504   jresult = (void *)result;
4505   return jresult;
4506 }
4507
4508
4509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4510   void * jresult ;
4511   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4512   Dali::Vector2 *arg2 = 0 ;
4513   Dali::Vector2 result;
4514
4515   arg1 = (Dali::Vector2 *)jarg1;
4516   arg2 = (Dali::Vector2 *)jarg2;
4517   if (!arg2) {
4518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4519     return 0;
4520   }
4521   {
4522     try {
4523       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4524     } catch (std::out_of_range& e) {
4525       {
4526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4527       };
4528     } catch (std::exception& e) {
4529       {
4530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4531       };
4532     } catch (Dali::DaliException e) {
4533       {
4534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4535       };
4536     } catch (...) {
4537       {
4538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4539       };
4540     }
4541   }
4542
4543   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4544   return jresult;
4545 }
4546
4547
4548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4549   void * jresult ;
4550   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4551   Dali::Vector2 *arg2 = 0 ;
4552   Dali::Vector2 *result = 0 ;
4553
4554   arg1 = (Dali::Vector2 *)jarg1;
4555   arg2 = (Dali::Vector2 *)jarg2;
4556   if (!arg2) {
4557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4558     return 0;
4559   }
4560   {
4561     try {
4562       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4563     } catch (std::out_of_range& e) {
4564       {
4565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4566       };
4567     } catch (std::exception& e) {
4568       {
4569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4570       };
4571     } catch (Dali::DaliException e) {
4572       {
4573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4574       };
4575     } catch (...) {
4576       {
4577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4578       };
4579     }
4580   }
4581
4582   jresult = (void *)result;
4583   return jresult;
4584 }
4585
4586
4587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4588   void * jresult ;
4589   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4590   Dali::Vector2 *arg2 = 0 ;
4591   Dali::Vector2 result;
4592
4593   arg1 = (Dali::Vector2 *)jarg1;
4594   arg2 = (Dali::Vector2 *)jarg2;
4595   if (!arg2) {
4596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4597     return 0;
4598   }
4599   {
4600     try {
4601       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4602     } catch (std::out_of_range& e) {
4603       {
4604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4605       };
4606     } catch (std::exception& e) {
4607       {
4608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4609       };
4610     } catch (Dali::DaliException e) {
4611       {
4612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4613       };
4614     } catch (...) {
4615       {
4616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4617       };
4618     }
4619   }
4620
4621   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4622   return jresult;
4623 }
4624
4625
4626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4627   void * jresult ;
4628   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4629   float arg2 ;
4630   Dali::Vector2 result;
4631
4632   arg1 = (Dali::Vector2 *)jarg1;
4633   arg2 = (float)jarg2;
4634   {
4635     try {
4636       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4637     } catch (std::out_of_range& e) {
4638       {
4639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4640       };
4641     } catch (std::exception& e) {
4642       {
4643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4644       };
4645     } catch (Dali::DaliException e) {
4646       {
4647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4648       };
4649     } catch (...) {
4650       {
4651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4652       };
4653     }
4654   }
4655
4656   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4657   return jresult;
4658 }
4659
4660
4661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4662   void * jresult ;
4663   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4664   Dali::Vector2 *arg2 = 0 ;
4665   Dali::Vector2 *result = 0 ;
4666
4667   arg1 = (Dali::Vector2 *)jarg1;
4668   arg2 = (Dali::Vector2 *)jarg2;
4669   if (!arg2) {
4670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4671     return 0;
4672   }
4673   {
4674     try {
4675       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4676     } catch (std::out_of_range& e) {
4677       {
4678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4679       };
4680     } catch (std::exception& e) {
4681       {
4682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4683       };
4684     } catch (Dali::DaliException e) {
4685       {
4686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4687       };
4688     } catch (...) {
4689       {
4690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4691       };
4692     }
4693   }
4694
4695   jresult = (void *)result;
4696   return jresult;
4697 }
4698
4699
4700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4701   void * jresult ;
4702   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4703   float arg2 ;
4704   Dali::Vector2 *result = 0 ;
4705
4706   arg1 = (Dali::Vector2 *)jarg1;
4707   arg2 = (float)jarg2;
4708   {
4709     try {
4710       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4711     } catch (std::out_of_range& e) {
4712       {
4713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4714       };
4715     } catch (std::exception& e) {
4716       {
4717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4718       };
4719     } catch (Dali::DaliException e) {
4720       {
4721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4722       };
4723     } catch (...) {
4724       {
4725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4726       };
4727     }
4728   }
4729
4730   jresult = (void *)result;
4731   return jresult;
4732 }
4733
4734
4735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4736   void * jresult ;
4737   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4738   Dali::Vector2 *arg2 = 0 ;
4739   Dali::Vector2 result;
4740
4741   arg1 = (Dali::Vector2 *)jarg1;
4742   arg2 = (Dali::Vector2 *)jarg2;
4743   if (!arg2) {
4744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4745     return 0;
4746   }
4747   {
4748     try {
4749       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4750     } catch (std::out_of_range& e) {
4751       {
4752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4753       };
4754     } catch (std::exception& e) {
4755       {
4756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4757       };
4758     } catch (Dali::DaliException e) {
4759       {
4760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4761       };
4762     } catch (...) {
4763       {
4764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4765       };
4766     }
4767   }
4768
4769   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4770   return jresult;
4771 }
4772
4773
4774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4775   void * jresult ;
4776   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4777   float arg2 ;
4778   Dali::Vector2 result;
4779
4780   arg1 = (Dali::Vector2 *)jarg1;
4781   arg2 = (float)jarg2;
4782   {
4783     try {
4784       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4785     } catch (std::out_of_range& e) {
4786       {
4787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4788       };
4789     } catch (std::exception& e) {
4790       {
4791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4792       };
4793     } catch (Dali::DaliException e) {
4794       {
4795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4796       };
4797     } catch (...) {
4798       {
4799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4800       };
4801     }
4802   }
4803
4804   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4805   return jresult;
4806 }
4807
4808
4809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4810   void * jresult ;
4811   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4812   Dali::Vector2 *arg2 = 0 ;
4813   Dali::Vector2 *result = 0 ;
4814
4815   arg1 = (Dali::Vector2 *)jarg1;
4816   arg2 = (Dali::Vector2 *)jarg2;
4817   if (!arg2) {
4818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4819     return 0;
4820   }
4821   {
4822     try {
4823       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4824     } catch (std::out_of_range& e) {
4825       {
4826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4827       };
4828     } catch (std::exception& e) {
4829       {
4830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4831       };
4832     } catch (Dali::DaliException e) {
4833       {
4834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4835       };
4836     } catch (...) {
4837       {
4838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4839       };
4840     }
4841   }
4842
4843   jresult = (void *)result;
4844   return jresult;
4845 }
4846
4847
4848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4849   void * jresult ;
4850   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4851   float arg2 ;
4852   Dali::Vector2 *result = 0 ;
4853
4854   arg1 = (Dali::Vector2 *)jarg1;
4855   arg2 = (float)jarg2;
4856   {
4857     try {
4858       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4859     } catch (std::out_of_range& e) {
4860       {
4861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4862       };
4863     } catch (std::exception& e) {
4864       {
4865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4866       };
4867     } catch (Dali::DaliException e) {
4868       {
4869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4870       };
4871     } catch (...) {
4872       {
4873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4874       };
4875     }
4876   }
4877
4878   jresult = (void *)result;
4879   return jresult;
4880 }
4881
4882
4883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
4884   void * jresult ;
4885   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4886   Dali::Vector2 result;
4887
4888   arg1 = (Dali::Vector2 *)jarg1;
4889   {
4890     try {
4891       result = ((Dali::Vector2 const *)arg1)->operator -();
4892     } catch (std::out_of_range& e) {
4893       {
4894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4895       };
4896     } catch (std::exception& e) {
4897       {
4898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4899       };
4900     } catch (Dali::DaliException e) {
4901       {
4902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4903       };
4904     } catch (...) {
4905       {
4906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4907       };
4908     }
4909   }
4910
4911   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4912   return jresult;
4913 }
4914
4915
4916 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
4917   unsigned int jresult ;
4918   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4919   Dali::Vector2 *arg2 = 0 ;
4920   bool result;
4921
4922   arg1 = (Dali::Vector2 *)jarg1;
4923   arg2 = (Dali::Vector2 *)jarg2;
4924   if (!arg2) {
4925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4926     return 0;
4927   }
4928   {
4929     try {
4930       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
4931     } catch (std::out_of_range& e) {
4932       {
4933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4934       };
4935     } catch (std::exception& e) {
4936       {
4937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4938       };
4939     } catch (Dali::DaliException e) {
4940       {
4941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4942       };
4943     } catch (...) {
4944       {
4945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4946       };
4947     }
4948   }
4949
4950   jresult = result;
4951   return jresult;
4952 }
4953
4954
4955 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
4956   unsigned int jresult ;
4957   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4958   Dali::Vector2 *arg2 = 0 ;
4959   bool result;
4960
4961   arg1 = (Dali::Vector2 *)jarg1;
4962   arg2 = (Dali::Vector2 *)jarg2;
4963   if (!arg2) {
4964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4965     return 0;
4966   }
4967   {
4968     try {
4969       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
4970     } catch (std::out_of_range& e) {
4971       {
4972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4973       };
4974     } catch (std::exception& e) {
4975       {
4976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4977       };
4978     } catch (Dali::DaliException e) {
4979       {
4980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4981       };
4982     } catch (...) {
4983       {
4984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4985       };
4986     }
4987   }
4988
4989   jresult = result;
4990   return jresult;
4991 }
4992
4993
4994 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
4995   float jresult ;
4996   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4997   unsigned int arg2 ;
4998   float *result = 0 ;
4999
5000   arg1 = (Dali::Vector2 *)jarg1;
5001   arg2 = (unsigned int)jarg2;
5002   {
5003     try {
5004       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
5005     } catch (std::out_of_range& e) {
5006       {
5007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5008       };
5009     } catch (std::exception& e) {
5010       {
5011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5012       };
5013     } catch (Dali::DaliException e) {
5014       {
5015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5016       };
5017     } catch (...) {
5018       {
5019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5020       };
5021     }
5022   }
5023
5024   jresult = *result;
5025   return jresult;
5026 }
5027
5028
5029 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
5030   float jresult ;
5031   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5032   float result;
5033
5034   arg1 = (Dali::Vector2 *)jarg1;
5035   {
5036     try {
5037       result = (float)((Dali::Vector2 const *)arg1)->Length();
5038     } catch (std::out_of_range& e) {
5039       {
5040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5041       };
5042     } catch (std::exception& e) {
5043       {
5044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5045       };
5046     } catch (Dali::DaliException e) {
5047       {
5048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5049       };
5050     } catch (...) {
5051       {
5052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5053       };
5054     }
5055   }
5056
5057   jresult = result;
5058   return jresult;
5059 }
5060
5061
5062 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
5063   float jresult ;
5064   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5065   float result;
5066
5067   arg1 = (Dali::Vector2 *)jarg1;
5068   {
5069     try {
5070       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
5071     } catch (std::out_of_range& e) {
5072       {
5073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5074       };
5075     } catch (std::exception& e) {
5076       {
5077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5078       };
5079     } catch (Dali::DaliException e) {
5080       {
5081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5082       };
5083     } catch (...) {
5084       {
5085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5086       };
5087     }
5088   }
5089
5090   jresult = result;
5091   return jresult;
5092 }
5093
5094
5095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
5096   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5097
5098   arg1 = (Dali::Vector2 *)jarg1;
5099   {
5100     try {
5101       (arg1)->Normalize();
5102     } catch (std::out_of_range& e) {
5103       {
5104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5105       };
5106     } catch (std::exception& e) {
5107       {
5108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5109       };
5110     } catch (Dali::DaliException e) {
5111       {
5112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5113       };
5114     } catch (...) {
5115       {
5116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5117       };
5118     }
5119   }
5120
5121 }
5122
5123
5124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5125   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5126   Dali::Vector2 *arg2 = 0 ;
5127   Dali::Vector2 *arg3 = 0 ;
5128
5129   arg1 = (Dali::Vector2 *)jarg1;
5130   arg2 = (Dali::Vector2 *)jarg2;
5131   if (!arg2) {
5132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5133     return ;
5134   }
5135   arg3 = (Dali::Vector2 *)jarg3;
5136   if (!arg3) {
5137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5138     return ;
5139   }
5140   {
5141     try {
5142       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
5143     } catch (std::out_of_range& e) {
5144       {
5145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5146       };
5147     } catch (std::exception& e) {
5148       {
5149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5150       };
5151     } catch (Dali::DaliException e) {
5152       {
5153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5154       };
5155     } catch (...) {
5156       {
5157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5158       };
5159     }
5160   }
5161
5162 }
5163
5164
5165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
5166   void * jresult ;
5167   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5168   float *result = 0 ;
5169
5170   arg1 = (Dali::Vector2 *)jarg1;
5171   {
5172     try {
5173       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
5174     } catch (std::out_of_range& e) {
5175       {
5176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5177       };
5178     } catch (std::exception& e) {
5179       {
5180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5181       };
5182     } catch (Dali::DaliException e) {
5183       {
5184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5185       };
5186     } catch (...) {
5187       {
5188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5189       };
5190     }
5191   }
5192
5193   jresult = (void *)result;
5194   return jresult;
5195 }
5196
5197
5198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
5199   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5200   float arg2 ;
5201
5202   arg1 = (Dali::Vector2 *)jarg1;
5203   arg2 = (float)jarg2;
5204   if (arg1) (arg1)->x = arg2;
5205 }
5206
5207
5208 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
5209   float jresult ;
5210   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5211   float result;
5212
5213   arg1 = (Dali::Vector2 *)jarg1;
5214   result = (float) ((arg1)->x);
5215   jresult = result;
5216   return jresult;
5217 }
5218
5219
5220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
5221   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5222   float arg2 ;
5223
5224   arg1 = (Dali::Vector2 *)jarg1;
5225   arg2 = (float)jarg2;
5226   if (arg1) (arg1)->width = arg2;
5227 }
5228
5229
5230 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
5231   float jresult ;
5232   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5233   float result;
5234
5235   arg1 = (Dali::Vector2 *)jarg1;
5236   result = (float) ((arg1)->width);
5237   jresult = result;
5238   return jresult;
5239 }
5240
5241
5242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
5243   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5244   float arg2 ;
5245
5246   arg1 = (Dali::Vector2 *)jarg1;
5247   arg2 = (float)jarg2;
5248   if (arg1) (arg1)->y = arg2;
5249 }
5250
5251
5252 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
5253   float jresult ;
5254   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5255   float result;
5256
5257   arg1 = (Dali::Vector2 *)jarg1;
5258   result = (float) ((arg1)->y);
5259   jresult = result;
5260   return jresult;
5261 }
5262
5263
5264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
5265   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5266   float arg2 ;
5267
5268   arg1 = (Dali::Vector2 *)jarg1;
5269   arg2 = (float)jarg2;
5270   if (arg1) (arg1)->height = arg2;
5271 }
5272
5273
5274 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
5275   float jresult ;
5276   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5277   float result;
5278
5279   arg1 = (Dali::Vector2 *)jarg1;
5280   result = (float) ((arg1)->height);
5281   jresult = result;
5282   return jresult;
5283 }
5284
5285
5286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
5287   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5288
5289   arg1 = (Dali::Vector2 *)jarg1;
5290   {
5291     try {
5292       delete arg1;
5293     } catch (std::out_of_range& e) {
5294       {
5295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5296       };
5297     } catch (std::exception& e) {
5298       {
5299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5300       };
5301     } catch (Dali::DaliException e) {
5302       {
5303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5304       };
5305     } catch (...) {
5306       {
5307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5308       };
5309     }
5310   }
5311
5312 }
5313
5314
5315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
5316   void * jresult ;
5317   Dali::Vector2 *arg1 = 0 ;
5318   Dali::Vector2 *arg2 = 0 ;
5319   Dali::Vector2 result;
5320
5321   arg1 = (Dali::Vector2 *)jarg1;
5322   if (!arg1) {
5323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5324     return 0;
5325   }
5326   arg2 = (Dali::Vector2 *)jarg2;
5327   if (!arg2) {
5328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5329     return 0;
5330   }
5331   {
5332     try {
5333       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5334     } catch (std::out_of_range& e) {
5335       {
5336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5337       };
5338     } catch (std::exception& e) {
5339       {
5340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5341       };
5342     } catch (Dali::DaliException e) {
5343       {
5344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5345       };
5346     } catch (...) {
5347       {
5348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5349       };
5350     }
5351   }
5352
5353   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5354   return jresult;
5355 }
5356
5357
5358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5359   void * jresult ;
5360   Dali::Vector2 *arg1 = 0 ;
5361   Dali::Vector2 *arg2 = 0 ;
5362   Dali::Vector2 result;
5363
5364   arg1 = (Dali::Vector2 *)jarg1;
5365   if (!arg1) {
5366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5367     return 0;
5368   }
5369   arg2 = (Dali::Vector2 *)jarg2;
5370   if (!arg2) {
5371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5372     return 0;
5373   }
5374   {
5375     try {
5376       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5377     } catch (std::out_of_range& e) {
5378       {
5379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5380       };
5381     } catch (std::exception& e) {
5382       {
5383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5384       };
5385     } catch (Dali::DaliException e) {
5386       {
5387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5388       };
5389     } catch (...) {
5390       {
5391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5392       };
5393     }
5394   }
5395
5396   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5397   return jresult;
5398 }
5399
5400
5401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5402   void * jresult ;
5403   Dali::Vector2 *arg1 = 0 ;
5404   float *arg2 = 0 ;
5405   float *arg3 = 0 ;
5406   float temp2 ;
5407   float temp3 ;
5408   Dali::Vector2 result;
5409
5410   arg1 = (Dali::Vector2 *)jarg1;
5411   if (!arg1) {
5412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5413     return 0;
5414   }
5415   temp2 = (float)jarg2;
5416   arg2 = &temp2;
5417   temp3 = (float)jarg3;
5418   arg3 = &temp3;
5419   {
5420     try {
5421       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5422     } catch (std::out_of_range& e) {
5423       {
5424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5425       };
5426     } catch (std::exception& e) {
5427       {
5428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5429       };
5430     } catch (Dali::DaliException e) {
5431       {
5432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5433       };
5434     } catch (...) {
5435       {
5436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5437       };
5438     }
5439   }
5440
5441   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5442   return jresult;
5443 }
5444
5445
5446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5447   void * jresult ;
5448   Dali::Vector3 *result = 0 ;
5449
5450   {
5451     try {
5452       result = (Dali::Vector3 *)new Dali::Vector3();
5453     } catch (std::out_of_range& e) {
5454       {
5455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5456       };
5457     } catch (std::exception& e) {
5458       {
5459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5460       };
5461     } catch (Dali::DaliException e) {
5462       {
5463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5464       };
5465     } catch (...) {
5466       {
5467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5468       };
5469     }
5470   }
5471
5472   jresult = (void *)result;
5473   return jresult;
5474 }
5475
5476
5477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5478   void * jresult ;
5479   float arg1 ;
5480   float arg2 ;
5481   float arg3 ;
5482   Dali::Vector3 *result = 0 ;
5483
5484   arg1 = (float)jarg1;
5485   arg2 = (float)jarg2;
5486   arg3 = (float)jarg3;
5487   {
5488     try {
5489       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5490     } catch (std::out_of_range& e) {
5491       {
5492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5493       };
5494     } catch (std::exception& e) {
5495       {
5496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5497       };
5498     } catch (Dali::DaliException e) {
5499       {
5500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5501       };
5502     } catch (...) {
5503       {
5504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5505       };
5506     }
5507   }
5508
5509   jresult = (void *)result;
5510   return jresult;
5511 }
5512
5513
5514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5515   void * jresult ;
5516   float *arg1 = (float *) 0 ;
5517   Dali::Vector3 *result = 0 ;
5518
5519   arg1 = jarg1;
5520   {
5521     try {
5522       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5523     } catch (std::out_of_range& e) {
5524       {
5525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5526       };
5527     } catch (std::exception& e) {
5528       {
5529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5530       };
5531     } catch (Dali::DaliException e) {
5532       {
5533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5534       };
5535     } catch (...) {
5536       {
5537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5538       };
5539     }
5540   }
5541
5542   jresult = (void *)result;
5543
5544
5545   return jresult;
5546 }
5547
5548
5549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5550   void * jresult ;
5551   Dali::Vector2 *arg1 = 0 ;
5552   Dali::Vector3 *result = 0 ;
5553
5554   arg1 = (Dali::Vector2 *)jarg1;
5555   if (!arg1) {
5556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5557     return 0;
5558   }
5559   {
5560     try {
5561       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5562     } catch (std::out_of_range& e) {
5563       {
5564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5565       };
5566     } catch (std::exception& e) {
5567       {
5568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5569       };
5570     } catch (Dali::DaliException e) {
5571       {
5572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5573       };
5574     } catch (...) {
5575       {
5576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5577       };
5578     }
5579   }
5580
5581   jresult = (void *)result;
5582   return jresult;
5583 }
5584
5585
5586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5587   void * jresult ;
5588   Dali::Vector4 *arg1 = 0 ;
5589   Dali::Vector3 *result = 0 ;
5590
5591   arg1 = (Dali::Vector4 *)jarg1;
5592   if (!arg1) {
5593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5594     return 0;
5595   }
5596   {
5597     try {
5598       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5599     } catch (std::out_of_range& e) {
5600       {
5601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5602       };
5603     } catch (std::exception& e) {
5604       {
5605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5606       };
5607     } catch (Dali::DaliException e) {
5608       {
5609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5610       };
5611     } catch (...) {
5612       {
5613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5614       };
5615     }
5616   }
5617
5618   jresult = (void *)result;
5619   return jresult;
5620 }
5621
5622
5623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5624   void * jresult ;
5625   Dali::Vector3 *result = 0 ;
5626
5627   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5628   jresult = (void *)result;
5629   return jresult;
5630 }
5631
5632
5633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5634   void * jresult ;
5635   Dali::Vector3 *result = 0 ;
5636
5637   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5638   jresult = (void *)result;
5639   return jresult;
5640 }
5641
5642
5643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5644   void * jresult ;
5645   Dali::Vector3 *result = 0 ;
5646
5647   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5648   jresult = (void *)result;
5649   return jresult;
5650 }
5651
5652
5653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5654   void * jresult ;
5655   Dali::Vector3 *result = 0 ;
5656
5657   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5658   jresult = (void *)result;
5659   return jresult;
5660 }
5661
5662
5663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5664   void * jresult ;
5665   Dali::Vector3 *result = 0 ;
5666
5667   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5668   jresult = (void *)result;
5669   return jresult;
5670 }
5671
5672
5673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5674   void * jresult ;
5675   Dali::Vector3 *result = 0 ;
5676
5677   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5678   jresult = (void *)result;
5679   return jresult;
5680 }
5681
5682
5683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5684   void * jresult ;
5685   Dali::Vector3 *result = 0 ;
5686
5687   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5688   jresult = (void *)result;
5689   return jresult;
5690 }
5691
5692
5693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5694   void * jresult ;
5695   Dali::Vector3 *result = 0 ;
5696
5697   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5698   jresult = (void *)result;
5699   return jresult;
5700 }
5701
5702
5703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5704   void * jresult ;
5705   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5706   float *arg2 = (float *) 0 ;
5707   Dali::Vector3 *result = 0 ;
5708
5709   arg1 = (Dali::Vector3 *)jarg1;
5710   arg2 = jarg2;
5711   {
5712     try {
5713       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5714     } catch (std::out_of_range& e) {
5715       {
5716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5717       };
5718     } catch (std::exception& e) {
5719       {
5720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5721       };
5722     } catch (Dali::DaliException e) {
5723       {
5724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5725       };
5726     } catch (...) {
5727       {
5728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5729       };
5730     }
5731   }
5732
5733   jresult = (void *)result;
5734
5735
5736   return jresult;
5737 }
5738
5739
5740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5741   void * jresult ;
5742   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5743   Dali::Vector2 *arg2 = 0 ;
5744   Dali::Vector3 *result = 0 ;
5745
5746   arg1 = (Dali::Vector3 *)jarg1;
5747   arg2 = (Dali::Vector2 *)jarg2;
5748   if (!arg2) {
5749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5750     return 0;
5751   }
5752   {
5753     try {
5754       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5755     } catch (std::out_of_range& e) {
5756       {
5757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5758       };
5759     } catch (std::exception& e) {
5760       {
5761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5762       };
5763     } catch (Dali::DaliException e) {
5764       {
5765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5766       };
5767     } catch (...) {
5768       {
5769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5770       };
5771     }
5772   }
5773
5774   jresult = (void *)result;
5775   return jresult;
5776 }
5777
5778
5779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5780   void * jresult ;
5781   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5782   Dali::Vector4 *arg2 = 0 ;
5783   Dali::Vector3 *result = 0 ;
5784
5785   arg1 = (Dali::Vector3 *)jarg1;
5786   arg2 = (Dali::Vector4 *)jarg2;
5787   if (!arg2) {
5788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5789     return 0;
5790   }
5791   {
5792     try {
5793       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5794     } catch (std::out_of_range& e) {
5795       {
5796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5797       };
5798     } catch (std::exception& e) {
5799       {
5800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5801       };
5802     } catch (Dali::DaliException e) {
5803       {
5804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5805       };
5806     } catch (...) {
5807       {
5808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5809       };
5810     }
5811   }
5812
5813   jresult = (void *)result;
5814   return jresult;
5815 }
5816
5817
5818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5819   void * jresult ;
5820   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5821   Dali::Vector3 *arg2 = 0 ;
5822   Dali::Vector3 result;
5823
5824   arg1 = (Dali::Vector3 *)jarg1;
5825   arg2 = (Dali::Vector3 *)jarg2;
5826   if (!arg2) {
5827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5828     return 0;
5829   }
5830   {
5831     try {
5832       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5833     } catch (std::out_of_range& e) {
5834       {
5835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5836       };
5837     } catch (std::exception& e) {
5838       {
5839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5840       };
5841     } catch (Dali::DaliException e) {
5842       {
5843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5844       };
5845     } catch (...) {
5846       {
5847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5848       };
5849     }
5850   }
5851
5852   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5853   return jresult;
5854 }
5855
5856
5857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5858   void * jresult ;
5859   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5860   Dali::Vector3 *arg2 = 0 ;
5861   Dali::Vector3 *result = 0 ;
5862
5863   arg1 = (Dali::Vector3 *)jarg1;
5864   arg2 = (Dali::Vector3 *)jarg2;
5865   if (!arg2) {
5866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5867     return 0;
5868   }
5869   {
5870     try {
5871       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
5872     } catch (std::out_of_range& e) {
5873       {
5874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5875       };
5876     } catch (std::exception& e) {
5877       {
5878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5879       };
5880     } catch (Dali::DaliException e) {
5881       {
5882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5883       };
5884     } catch (...) {
5885       {
5886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5887       };
5888     }
5889   }
5890
5891   jresult = (void *)result;
5892   return jresult;
5893 }
5894
5895
5896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
5897   void * jresult ;
5898   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5899   Dali::Vector3 *arg2 = 0 ;
5900   Dali::Vector3 result;
5901
5902   arg1 = (Dali::Vector3 *)jarg1;
5903   arg2 = (Dali::Vector3 *)jarg2;
5904   if (!arg2) {
5905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5906     return 0;
5907   }
5908   {
5909     try {
5910       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
5911     } catch (std::out_of_range& e) {
5912       {
5913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5914       };
5915     } catch (std::exception& e) {
5916       {
5917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5918       };
5919     } catch (Dali::DaliException e) {
5920       {
5921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5922       };
5923     } catch (...) {
5924       {
5925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5926       };
5927     }
5928   }
5929
5930   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5931   return jresult;
5932 }
5933
5934
5935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
5936   void * jresult ;
5937   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5938   Dali::Vector3 *arg2 = 0 ;
5939   Dali::Vector3 *result = 0 ;
5940
5941   arg1 = (Dali::Vector3 *)jarg1;
5942   arg2 = (Dali::Vector3 *)jarg2;
5943   if (!arg2) {
5944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5945     return 0;
5946   }
5947   {
5948     try {
5949       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
5950     } catch (std::out_of_range& e) {
5951       {
5952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5953       };
5954     } catch (std::exception& e) {
5955       {
5956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5957       };
5958     } catch (Dali::DaliException e) {
5959       {
5960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5961       };
5962     } catch (...) {
5963       {
5964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5965       };
5966     }
5967   }
5968
5969   jresult = (void *)result;
5970   return jresult;
5971 }
5972
5973
5974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
5975   void * jresult ;
5976   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5977   Dali::Vector3 *arg2 = 0 ;
5978   Dali::Vector3 result;
5979
5980   arg1 = (Dali::Vector3 *)jarg1;
5981   arg2 = (Dali::Vector3 *)jarg2;
5982   if (!arg2) {
5983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5984     return 0;
5985   }
5986   {
5987     try {
5988       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
5989     } catch (std::out_of_range& e) {
5990       {
5991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5992       };
5993     } catch (std::exception& e) {
5994       {
5995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5996       };
5997     } catch (Dali::DaliException e) {
5998       {
5999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6000       };
6001     } catch (...) {
6002       {
6003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6004       };
6005     }
6006   }
6007
6008   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6009   return jresult;
6010 }
6011
6012
6013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
6014   void * jresult ;
6015   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6016   float arg2 ;
6017   Dali::Vector3 result;
6018
6019   arg1 = (Dali::Vector3 *)jarg1;
6020   arg2 = (float)jarg2;
6021   {
6022     try {
6023       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
6024     } catch (std::out_of_range& e) {
6025       {
6026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6027       };
6028     } catch (std::exception& e) {
6029       {
6030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6031       };
6032     } catch (Dali::DaliException e) {
6033       {
6034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6035       };
6036     } catch (...) {
6037       {
6038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6039       };
6040     }
6041   }
6042
6043   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6044   return jresult;
6045 }
6046
6047
6048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6049   void * jresult ;
6050   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6051   Dali::Vector3 *arg2 = 0 ;
6052   Dali::Vector3 *result = 0 ;
6053
6054   arg1 = (Dali::Vector3 *)jarg1;
6055   arg2 = (Dali::Vector3 *)jarg2;
6056   if (!arg2) {
6057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6058     return 0;
6059   }
6060   {
6061     try {
6062       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
6063     } catch (std::out_of_range& e) {
6064       {
6065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6066       };
6067     } catch (std::exception& e) {
6068       {
6069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6070       };
6071     } catch (Dali::DaliException e) {
6072       {
6073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6074       };
6075     } catch (...) {
6076       {
6077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6078       };
6079     }
6080   }
6081
6082   jresult = (void *)result;
6083   return jresult;
6084 }
6085
6086
6087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
6088   void * jresult ;
6089   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6090   float arg2 ;
6091   Dali::Vector3 *result = 0 ;
6092
6093   arg1 = (Dali::Vector3 *)jarg1;
6094   arg2 = (float)jarg2;
6095   {
6096     try {
6097       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
6098     } catch (std::out_of_range& e) {
6099       {
6100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6101       };
6102     } catch (std::exception& e) {
6103       {
6104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6105       };
6106     } catch (Dali::DaliException e) {
6107       {
6108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6109       };
6110     } catch (...) {
6111       {
6112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6113       };
6114     }
6115   }
6116
6117   jresult = (void *)result;
6118   return jresult;
6119 }
6120
6121
6122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
6123   void * jresult ;
6124   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6125   Dali::Quaternion *arg2 = 0 ;
6126   Dali::Vector3 *result = 0 ;
6127
6128   arg1 = (Dali::Vector3 *)jarg1;
6129   arg2 = (Dali::Quaternion *)jarg2;
6130   if (!arg2) {
6131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
6132     return 0;
6133   }
6134   {
6135     try {
6136       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
6137     } catch (std::out_of_range& e) {
6138       {
6139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6140       };
6141     } catch (std::exception& e) {
6142       {
6143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6144       };
6145     } catch (Dali::DaliException e) {
6146       {
6147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6148       };
6149     } catch (...) {
6150       {
6151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6152       };
6153     }
6154   }
6155
6156   jresult = (void *)result;
6157   return jresult;
6158 }
6159
6160
6161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
6162   void * jresult ;
6163   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6164   Dali::Vector3 *arg2 = 0 ;
6165   Dali::Vector3 result;
6166
6167   arg1 = (Dali::Vector3 *)jarg1;
6168   arg2 = (Dali::Vector3 *)jarg2;
6169   if (!arg2) {
6170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6171     return 0;
6172   }
6173   {
6174     try {
6175       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
6176     } catch (std::out_of_range& e) {
6177       {
6178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6179       };
6180     } catch (std::exception& e) {
6181       {
6182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6183       };
6184     } catch (Dali::DaliException e) {
6185       {
6186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6187       };
6188     } catch (...) {
6189       {
6190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6191       };
6192     }
6193   }
6194
6195   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6196   return jresult;
6197 }
6198
6199
6200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
6201   void * jresult ;
6202   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6203   float arg2 ;
6204   Dali::Vector3 result;
6205
6206   arg1 = (Dali::Vector3 *)jarg1;
6207   arg2 = (float)jarg2;
6208   {
6209     try {
6210       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
6211     } catch (std::out_of_range& e) {
6212       {
6213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6214       };
6215     } catch (std::exception& e) {
6216       {
6217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6218       };
6219     } catch (Dali::DaliException e) {
6220       {
6221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6222       };
6223     } catch (...) {
6224       {
6225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6226       };
6227     }
6228   }
6229
6230   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6231   return jresult;
6232 }
6233
6234
6235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
6236   void * jresult ;
6237   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6238   Dali::Vector3 *arg2 = 0 ;
6239   Dali::Vector3 *result = 0 ;
6240
6241   arg1 = (Dali::Vector3 *)jarg1;
6242   arg2 = (Dali::Vector3 *)jarg2;
6243   if (!arg2) {
6244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6245     return 0;
6246   }
6247   {
6248     try {
6249       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
6250     } catch (std::out_of_range& e) {
6251       {
6252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6253       };
6254     } catch (std::exception& e) {
6255       {
6256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6257       };
6258     } catch (Dali::DaliException e) {
6259       {
6260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6261       };
6262     } catch (...) {
6263       {
6264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6265       };
6266     }
6267   }
6268
6269   jresult = (void *)result;
6270   return jresult;
6271 }
6272
6273
6274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
6275   void * jresult ;
6276   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6277   float arg2 ;
6278   Dali::Vector3 *result = 0 ;
6279
6280   arg1 = (Dali::Vector3 *)jarg1;
6281   arg2 = (float)jarg2;
6282   {
6283     try {
6284       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
6285     } catch (std::out_of_range& e) {
6286       {
6287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6288       };
6289     } catch (std::exception& e) {
6290       {
6291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6292       };
6293     } catch (Dali::DaliException e) {
6294       {
6295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6296       };
6297     } catch (...) {
6298       {
6299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6300       };
6301     }
6302   }
6303
6304   jresult = (void *)result;
6305   return jresult;
6306 }
6307
6308
6309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
6310   void * jresult ;
6311   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6312   Dali::Vector3 result;
6313
6314   arg1 = (Dali::Vector3 *)jarg1;
6315   {
6316     try {
6317       result = ((Dali::Vector3 const *)arg1)->operator -();
6318     } catch (std::out_of_range& e) {
6319       {
6320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6321       };
6322     } catch (std::exception& e) {
6323       {
6324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6325       };
6326     } catch (Dali::DaliException e) {
6327       {
6328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6329       };
6330     } catch (...) {
6331       {
6332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6333       };
6334     }
6335   }
6336
6337   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6338   return jresult;
6339 }
6340
6341
6342 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
6343   unsigned int jresult ;
6344   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6345   Dali::Vector3 *arg2 = 0 ;
6346   bool result;
6347
6348   arg1 = (Dali::Vector3 *)jarg1;
6349   arg2 = (Dali::Vector3 *)jarg2;
6350   if (!arg2) {
6351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6352     return 0;
6353   }
6354   {
6355     try {
6356       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
6357     } catch (std::out_of_range& e) {
6358       {
6359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6360       };
6361     } catch (std::exception& e) {
6362       {
6363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6364       };
6365     } catch (Dali::DaliException e) {
6366       {
6367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6368       };
6369     } catch (...) {
6370       {
6371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6372       };
6373     }
6374   }
6375
6376   jresult = result;
6377   return jresult;
6378 }
6379
6380
6381 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
6382   unsigned int jresult ;
6383   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6384   Dali::Vector3 *arg2 = 0 ;
6385   bool result;
6386
6387   arg1 = (Dali::Vector3 *)jarg1;
6388   arg2 = (Dali::Vector3 *)jarg2;
6389   if (!arg2) {
6390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6391     return 0;
6392   }
6393   {
6394     try {
6395       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
6396     } catch (std::out_of_range& e) {
6397       {
6398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6399       };
6400     } catch (std::exception& e) {
6401       {
6402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6403       };
6404     } catch (Dali::DaliException e) {
6405       {
6406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6407       };
6408     } catch (...) {
6409       {
6410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6411       };
6412     }
6413   }
6414
6415   jresult = result;
6416   return jresult;
6417 }
6418
6419
6420 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
6421   float jresult ;
6422   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6423   unsigned int arg2 ;
6424   float *result = 0 ;
6425
6426   arg1 = (Dali::Vector3 *)jarg1;
6427   arg2 = (unsigned int)jarg2;
6428   {
6429     try {
6430       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
6431     } catch (std::out_of_range& e) {
6432       {
6433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6434       };
6435     } catch (std::exception& e) {
6436       {
6437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6438       };
6439     } catch (Dali::DaliException e) {
6440       {
6441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6442       };
6443     } catch (...) {
6444       {
6445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6446       };
6447     }
6448   }
6449
6450   jresult = *result;
6451   return jresult;
6452 }
6453
6454
6455 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
6456   float jresult ;
6457   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6458   Dali::Vector3 *arg2 = 0 ;
6459   float result;
6460
6461   arg1 = (Dali::Vector3 *)jarg1;
6462   arg2 = (Dali::Vector3 *)jarg2;
6463   if (!arg2) {
6464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6465     return 0;
6466   }
6467   {
6468     try {
6469       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
6470     } catch (std::out_of_range& e) {
6471       {
6472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6473       };
6474     } catch (std::exception& e) {
6475       {
6476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6477       };
6478     } catch (Dali::DaliException e) {
6479       {
6480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6481       };
6482     } catch (...) {
6483       {
6484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6485       };
6486     }
6487   }
6488
6489   jresult = result;
6490   return jresult;
6491 }
6492
6493
6494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6495   void * jresult ;
6496   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6497   Dali::Vector3 *arg2 = 0 ;
6498   Dali::Vector3 result;
6499
6500   arg1 = (Dali::Vector3 *)jarg1;
6501   arg2 = (Dali::Vector3 *)jarg2;
6502   if (!arg2) {
6503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6504     return 0;
6505   }
6506   {
6507     try {
6508       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6509     } catch (std::out_of_range& e) {
6510       {
6511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6512       };
6513     } catch (std::exception& e) {
6514       {
6515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6516       };
6517     } catch (Dali::DaliException e) {
6518       {
6519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6520       };
6521     } catch (...) {
6522       {
6523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6524       };
6525     }
6526   }
6527
6528   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6529   return jresult;
6530 }
6531
6532
6533 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6534   float jresult ;
6535   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6536   float result;
6537
6538   arg1 = (Dali::Vector3 *)jarg1;
6539   {
6540     try {
6541       result = (float)((Dali::Vector3 const *)arg1)->Length();
6542     } catch (std::out_of_range& e) {
6543       {
6544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6545       };
6546     } catch (std::exception& e) {
6547       {
6548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6549       };
6550     } catch (Dali::DaliException e) {
6551       {
6552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6553       };
6554     } catch (...) {
6555       {
6556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6557       };
6558     }
6559   }
6560
6561   jresult = result;
6562   return jresult;
6563 }
6564
6565
6566 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6567   float jresult ;
6568   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6569   float result;
6570
6571   arg1 = (Dali::Vector3 *)jarg1;
6572   {
6573     try {
6574       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6575     } catch (std::out_of_range& e) {
6576       {
6577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6578       };
6579     } catch (std::exception& e) {
6580       {
6581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6582       };
6583     } catch (Dali::DaliException e) {
6584       {
6585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6586       };
6587     } catch (...) {
6588       {
6589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6590       };
6591     }
6592   }
6593
6594   jresult = result;
6595   return jresult;
6596 }
6597
6598
6599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6600   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6601
6602   arg1 = (Dali::Vector3 *)jarg1;
6603   {
6604     try {
6605       (arg1)->Normalize();
6606     } catch (std::out_of_range& e) {
6607       {
6608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6609       };
6610     } catch (std::exception& e) {
6611       {
6612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6613       };
6614     } catch (Dali::DaliException e) {
6615       {
6616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6617       };
6618     } catch (...) {
6619       {
6620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6621       };
6622     }
6623   }
6624
6625 }
6626
6627
6628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6629   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6630   Dali::Vector3 *arg2 = 0 ;
6631   Dali::Vector3 *arg3 = 0 ;
6632
6633   arg1 = (Dali::Vector3 *)jarg1;
6634   arg2 = (Dali::Vector3 *)jarg2;
6635   if (!arg2) {
6636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6637     return ;
6638   }
6639   arg3 = (Dali::Vector3 *)jarg3;
6640   if (!arg3) {
6641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6642     return ;
6643   }
6644   {
6645     try {
6646       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6647     } catch (std::out_of_range& e) {
6648       {
6649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6650       };
6651     } catch (std::exception& e) {
6652       {
6653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6654       };
6655     } catch (Dali::DaliException e) {
6656       {
6657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6658       };
6659     } catch (...) {
6660       {
6661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6662       };
6663     }
6664   }
6665
6666 }
6667
6668
6669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6670   void * jresult ;
6671   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6672   float *result = 0 ;
6673
6674   arg1 = (Dali::Vector3 *)jarg1;
6675   {
6676     try {
6677       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6678     } catch (std::out_of_range& e) {
6679       {
6680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6681       };
6682     } catch (std::exception& e) {
6683       {
6684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6685       };
6686     } catch (Dali::DaliException e) {
6687       {
6688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6689       };
6690     } catch (...) {
6691       {
6692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6693       };
6694     }
6695   }
6696
6697   jresult = (void *)result;
6698   return jresult;
6699 }
6700
6701
6702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6703   void * jresult ;
6704   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6705   Dali::Vector2 *result = 0 ;
6706
6707   arg1 = (Dali::Vector3 *)jarg1;
6708   {
6709     try {
6710       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6711     } catch (std::out_of_range& e) {
6712       {
6713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6714       };
6715     } catch (std::exception& e) {
6716       {
6717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6718       };
6719     } catch (Dali::DaliException e) {
6720       {
6721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6722       };
6723     } catch (...) {
6724       {
6725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6726       };
6727     }
6728   }
6729
6730   jresult = (void *)result;
6731   return jresult;
6732 }
6733
6734
6735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6736   void * jresult ;
6737   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6738   Dali::Vector2 *result = 0 ;
6739
6740   arg1 = (Dali::Vector3 *)jarg1;
6741   {
6742     try {
6743       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6744     } catch (std::out_of_range& e) {
6745       {
6746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6747       };
6748     } catch (std::exception& e) {
6749       {
6750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6751       };
6752     } catch (Dali::DaliException e) {
6753       {
6754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6755       };
6756     } catch (...) {
6757       {
6758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6759       };
6760     }
6761   }
6762
6763   jresult = (void *)result;
6764   return jresult;
6765 }
6766
6767
6768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6769   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6770   float arg2 ;
6771
6772   arg1 = (Dali::Vector3 *)jarg1;
6773   arg2 = (float)jarg2;
6774   if (arg1) (arg1)->x = arg2;
6775 }
6776
6777
6778 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6779   float jresult ;
6780   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6781   float result;
6782
6783   arg1 = (Dali::Vector3 *)jarg1;
6784   result = (float) ((arg1)->x);
6785   jresult = result;
6786   return jresult;
6787 }
6788
6789
6790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6791   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6792   float arg2 ;
6793
6794   arg1 = (Dali::Vector3 *)jarg1;
6795   arg2 = (float)jarg2;
6796   if (arg1) (arg1)->width = arg2;
6797 }
6798
6799
6800 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6801   float jresult ;
6802   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6803   float result;
6804
6805   arg1 = (Dali::Vector3 *)jarg1;
6806   result = (float) ((arg1)->width);
6807   jresult = result;
6808   return jresult;
6809 }
6810
6811
6812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6813   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6814   float arg2 ;
6815
6816   arg1 = (Dali::Vector3 *)jarg1;
6817   arg2 = (float)jarg2;
6818   if (arg1) (arg1)->r = arg2;
6819 }
6820
6821
6822 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6823   float jresult ;
6824   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6825   float result;
6826
6827   arg1 = (Dali::Vector3 *)jarg1;
6828   result = (float) ((arg1)->r);
6829   jresult = result;
6830   return jresult;
6831 }
6832
6833
6834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6835   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6836   float arg2 ;
6837
6838   arg1 = (Dali::Vector3 *)jarg1;
6839   arg2 = (float)jarg2;
6840   if (arg1) (arg1)->y = arg2;
6841 }
6842
6843
6844 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6845   float jresult ;
6846   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6847   float result;
6848
6849   arg1 = (Dali::Vector3 *)jarg1;
6850   result = (float) ((arg1)->y);
6851   jresult = result;
6852   return jresult;
6853 }
6854
6855
6856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6857   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6858   float arg2 ;
6859
6860   arg1 = (Dali::Vector3 *)jarg1;
6861   arg2 = (float)jarg2;
6862   if (arg1) (arg1)->height = arg2;
6863 }
6864
6865
6866 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
6867   float jresult ;
6868   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6869   float result;
6870
6871   arg1 = (Dali::Vector3 *)jarg1;
6872   result = (float) ((arg1)->height);
6873   jresult = result;
6874   return jresult;
6875 }
6876
6877
6878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
6879   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6880   float arg2 ;
6881
6882   arg1 = (Dali::Vector3 *)jarg1;
6883   arg2 = (float)jarg2;
6884   if (arg1) (arg1)->g = arg2;
6885 }
6886
6887
6888 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
6889   float jresult ;
6890   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6891   float result;
6892
6893   arg1 = (Dali::Vector3 *)jarg1;
6894   result = (float) ((arg1)->g);
6895   jresult = result;
6896   return jresult;
6897 }
6898
6899
6900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
6901   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6902   float arg2 ;
6903
6904   arg1 = (Dali::Vector3 *)jarg1;
6905   arg2 = (float)jarg2;
6906   if (arg1) (arg1)->z = arg2;
6907 }
6908
6909
6910 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
6911   float jresult ;
6912   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6913   float result;
6914
6915   arg1 = (Dali::Vector3 *)jarg1;
6916   result = (float) ((arg1)->z);
6917   jresult = result;
6918   return jresult;
6919 }
6920
6921
6922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
6923   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6924   float arg2 ;
6925
6926   arg1 = (Dali::Vector3 *)jarg1;
6927   arg2 = (float)jarg2;
6928   if (arg1) (arg1)->depth = arg2;
6929 }
6930
6931
6932 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
6933   float jresult ;
6934   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6935   float result;
6936
6937   arg1 = (Dali::Vector3 *)jarg1;
6938   result = (float) ((arg1)->depth);
6939   jresult = result;
6940   return jresult;
6941 }
6942
6943
6944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
6945   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6946   float arg2 ;
6947
6948   arg1 = (Dali::Vector3 *)jarg1;
6949   arg2 = (float)jarg2;
6950   if (arg1) (arg1)->b = arg2;
6951 }
6952
6953
6954 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
6955   float jresult ;
6956   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6957   float result;
6958
6959   arg1 = (Dali::Vector3 *)jarg1;
6960   result = (float) ((arg1)->b);
6961   jresult = result;
6962   return jresult;
6963 }
6964
6965
6966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
6967   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6968
6969   arg1 = (Dali::Vector3 *)jarg1;
6970   {
6971     try {
6972       delete arg1;
6973     } catch (std::out_of_range& e) {
6974       {
6975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6976       };
6977     } catch (std::exception& e) {
6978       {
6979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6980       };
6981     } catch (Dali::DaliException e) {
6982       {
6983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6984       };
6985     } catch (...) {
6986       {
6987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6988       };
6989     }
6990   }
6991
6992 }
6993
6994
6995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
6996   void * jresult ;
6997   Dali::Vector3 *arg1 = 0 ;
6998   Dali::Vector3 *arg2 = 0 ;
6999   Dali::Vector3 result;
7000
7001   arg1 = (Dali::Vector3 *)jarg1;
7002   if (!arg1) {
7003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7004     return 0;
7005   }
7006   arg2 = (Dali::Vector3 *)jarg2;
7007   if (!arg2) {
7008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7009     return 0;
7010   }
7011   {
7012     try {
7013       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7014     } catch (std::out_of_range& e) {
7015       {
7016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7017       };
7018     } catch (std::exception& e) {
7019       {
7020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7021       };
7022     } catch (Dali::DaliException e) {
7023       {
7024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7025       };
7026     } catch (...) {
7027       {
7028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7029       };
7030     }
7031   }
7032
7033   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7034   return jresult;
7035 }
7036
7037
7038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
7039   void * jresult ;
7040   Dali::Vector3 *arg1 = 0 ;
7041   Dali::Vector3 *arg2 = 0 ;
7042   Dali::Vector3 result;
7043
7044   arg1 = (Dali::Vector3 *)jarg1;
7045   if (!arg1) {
7046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7047     return 0;
7048   }
7049   arg2 = (Dali::Vector3 *)jarg2;
7050   if (!arg2) {
7051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7052     return 0;
7053   }
7054   {
7055     try {
7056       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7057     } catch (std::out_of_range& e) {
7058       {
7059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7060       };
7061     } catch (std::exception& e) {
7062       {
7063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7064       };
7065     } catch (Dali::DaliException e) {
7066       {
7067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7068       };
7069     } catch (...) {
7070       {
7071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7072       };
7073     }
7074   }
7075
7076   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7077   return jresult;
7078 }
7079
7080
7081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
7082   void * jresult ;
7083   Dali::Vector3 *arg1 = 0 ;
7084   float *arg2 = 0 ;
7085   float *arg3 = 0 ;
7086   float temp2 ;
7087   float temp3 ;
7088   Dali::Vector3 result;
7089
7090   arg1 = (Dali::Vector3 *)jarg1;
7091   if (!arg1) {
7092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7093     return 0;
7094   }
7095   temp2 = (float)jarg2;
7096   arg2 = &temp2;
7097   temp3 = (float)jarg3;
7098   arg3 = &temp3;
7099   {
7100     try {
7101       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7102     } catch (std::out_of_range& e) {
7103       {
7104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7105       };
7106     } catch (std::exception& e) {
7107       {
7108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7109       };
7110     } catch (Dali::DaliException e) {
7111       {
7112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7113       };
7114     } catch (...) {
7115       {
7116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7117       };
7118     }
7119   }
7120
7121   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7122   return jresult;
7123 }
7124
7125
7126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
7127   void * jresult ;
7128   Dali::Vector4 *result = 0 ;
7129
7130   {
7131     try {
7132       result = (Dali::Vector4 *)new Dali::Vector4();
7133     } catch (std::out_of_range& e) {
7134       {
7135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7136       };
7137     } catch (std::exception& e) {
7138       {
7139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7140       };
7141     } catch (Dali::DaliException e) {
7142       {
7143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7144       };
7145     } catch (...) {
7146       {
7147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7148       };
7149     }
7150   }
7151
7152   jresult = (void *)result;
7153   return jresult;
7154 }
7155
7156
7157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
7158   void * jresult ;
7159   float arg1 ;
7160   float arg2 ;
7161   float arg3 ;
7162   float arg4 ;
7163   Dali::Vector4 *result = 0 ;
7164
7165   arg1 = (float)jarg1;
7166   arg2 = (float)jarg2;
7167   arg3 = (float)jarg3;
7168   arg4 = (float)jarg4;
7169   {
7170     try {
7171       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
7172     } catch (std::out_of_range& e) {
7173       {
7174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7175       };
7176     } catch (std::exception& e) {
7177       {
7178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7179       };
7180     } catch (Dali::DaliException e) {
7181       {
7182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7183       };
7184     } catch (...) {
7185       {
7186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7187       };
7188     }
7189   }
7190
7191   jresult = (void *)result;
7192   return jresult;
7193 }
7194
7195
7196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
7197   void * jresult ;
7198   float *arg1 = (float *) 0 ;
7199   Dali::Vector4 *result = 0 ;
7200
7201   arg1 = jarg1;
7202   {
7203     try {
7204       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
7205     } catch (std::out_of_range& e) {
7206       {
7207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7208       };
7209     } catch (std::exception& e) {
7210       {
7211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7212       };
7213     } catch (Dali::DaliException e) {
7214       {
7215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7216       };
7217     } catch (...) {
7218       {
7219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7220       };
7221     }
7222   }
7223
7224   jresult = (void *)result;
7225
7226
7227   return jresult;
7228 }
7229
7230
7231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
7232   void * jresult ;
7233   Dali::Vector2 *arg1 = 0 ;
7234   Dali::Vector4 *result = 0 ;
7235
7236   arg1 = (Dali::Vector2 *)jarg1;
7237   if (!arg1) {
7238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7239     return 0;
7240   }
7241   {
7242     try {
7243       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
7244     } catch (std::out_of_range& e) {
7245       {
7246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7247       };
7248     } catch (std::exception& e) {
7249       {
7250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7251       };
7252     } catch (Dali::DaliException e) {
7253       {
7254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7255       };
7256     } catch (...) {
7257       {
7258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7259       };
7260     }
7261   }
7262
7263   jresult = (void *)result;
7264   return jresult;
7265 }
7266
7267
7268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
7269   void * jresult ;
7270   Dali::Vector3 *arg1 = 0 ;
7271   Dali::Vector4 *result = 0 ;
7272
7273   arg1 = (Dali::Vector3 *)jarg1;
7274   if (!arg1) {
7275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7276     return 0;
7277   }
7278   {
7279     try {
7280       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
7281     } catch (std::out_of_range& e) {
7282       {
7283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7284       };
7285     } catch (std::exception& e) {
7286       {
7287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7288       };
7289     } catch (Dali::DaliException e) {
7290       {
7291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7292       };
7293     } catch (...) {
7294       {
7295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7296       };
7297     }
7298   }
7299
7300   jresult = (void *)result;
7301   return jresult;
7302 }
7303
7304
7305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
7306   void * jresult ;
7307   Dali::Vector4 *result = 0 ;
7308
7309   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
7310   jresult = (void *)result;
7311   return jresult;
7312 }
7313
7314
7315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
7316   void * jresult ;
7317   Dali::Vector4 *result = 0 ;
7318
7319   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
7320   jresult = (void *)result;
7321   return jresult;
7322 }
7323
7324
7325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
7326   void * jresult ;
7327   Dali::Vector4 *result = 0 ;
7328
7329   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
7330   jresult = (void *)result;
7331   return jresult;
7332 }
7333
7334
7335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
7336   void * jresult ;
7337   Dali::Vector4 *result = 0 ;
7338
7339   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
7340   jresult = (void *)result;
7341   return jresult;
7342 }
7343
7344
7345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
7346   void * jresult ;
7347   Dali::Vector4 *result = 0 ;
7348
7349   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
7350   jresult = (void *)result;
7351   return jresult;
7352 }
7353
7354
7355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
7356   void * jresult ;
7357   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7358   float *arg2 = (float *) 0 ;
7359   Dali::Vector4 *result = 0 ;
7360
7361   arg1 = (Dali::Vector4 *)jarg1;
7362   arg2 = jarg2;
7363   {
7364     try {
7365       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
7366     } catch (std::out_of_range& e) {
7367       {
7368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7369       };
7370     } catch (std::exception& e) {
7371       {
7372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7373       };
7374     } catch (Dali::DaliException e) {
7375       {
7376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7377       };
7378     } catch (...) {
7379       {
7380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7381       };
7382     }
7383   }
7384
7385   jresult = (void *)result;
7386
7387
7388   return jresult;
7389 }
7390
7391
7392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
7393   void * jresult ;
7394   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7395   Dali::Vector2 *arg2 = 0 ;
7396   Dali::Vector4 *result = 0 ;
7397
7398   arg1 = (Dali::Vector4 *)jarg1;
7399   arg2 = (Dali::Vector2 *)jarg2;
7400   if (!arg2) {
7401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7402     return 0;
7403   }
7404   {
7405     try {
7406       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
7407     } catch (std::out_of_range& e) {
7408       {
7409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7410       };
7411     } catch (std::exception& e) {
7412       {
7413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7414       };
7415     } catch (Dali::DaliException e) {
7416       {
7417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7418       };
7419     } catch (...) {
7420       {
7421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7422       };
7423     }
7424   }
7425
7426   jresult = (void *)result;
7427   return jresult;
7428 }
7429
7430
7431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
7432   void * jresult ;
7433   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7434   Dali::Vector3 *arg2 = 0 ;
7435   Dali::Vector4 *result = 0 ;
7436
7437   arg1 = (Dali::Vector4 *)jarg1;
7438   arg2 = (Dali::Vector3 *)jarg2;
7439   if (!arg2) {
7440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7441     return 0;
7442   }
7443   {
7444     try {
7445       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
7446     } catch (std::out_of_range& e) {
7447       {
7448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7449       };
7450     } catch (std::exception& e) {
7451       {
7452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7453       };
7454     } catch (Dali::DaliException e) {
7455       {
7456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7457       };
7458     } catch (...) {
7459       {
7460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7461       };
7462     }
7463   }
7464
7465   jresult = (void *)result;
7466   return jresult;
7467 }
7468
7469
7470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
7471   void * jresult ;
7472   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7473   Dali::Vector4 *arg2 = 0 ;
7474   Dali::Vector4 result;
7475
7476   arg1 = (Dali::Vector4 *)jarg1;
7477   arg2 = (Dali::Vector4 *)jarg2;
7478   if (!arg2) {
7479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7480     return 0;
7481   }
7482   {
7483     try {
7484       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
7485     } catch (std::out_of_range& e) {
7486       {
7487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7488       };
7489     } catch (std::exception& e) {
7490       {
7491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7492       };
7493     } catch (Dali::DaliException e) {
7494       {
7495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7496       };
7497     } catch (...) {
7498       {
7499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7500       };
7501     }
7502   }
7503
7504   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7505   return jresult;
7506 }
7507
7508
7509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
7510   void * jresult ;
7511   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7512   Dali::Vector4 *arg2 = 0 ;
7513   Dali::Vector4 *result = 0 ;
7514
7515   arg1 = (Dali::Vector4 *)jarg1;
7516   arg2 = (Dali::Vector4 *)jarg2;
7517   if (!arg2) {
7518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7519     return 0;
7520   }
7521   {
7522     try {
7523       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
7524     } catch (std::out_of_range& e) {
7525       {
7526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7527       };
7528     } catch (std::exception& e) {
7529       {
7530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7531       };
7532     } catch (Dali::DaliException e) {
7533       {
7534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7535       };
7536     } catch (...) {
7537       {
7538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7539       };
7540     }
7541   }
7542
7543   jresult = (void *)result;
7544   return jresult;
7545 }
7546
7547
7548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
7549   void * jresult ;
7550   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7551   Dali::Vector4 *arg2 = 0 ;
7552   Dali::Vector4 result;
7553
7554   arg1 = (Dali::Vector4 *)jarg1;
7555   arg2 = (Dali::Vector4 *)jarg2;
7556   if (!arg2) {
7557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7558     return 0;
7559   }
7560   {
7561     try {
7562       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
7563     } catch (std::out_of_range& e) {
7564       {
7565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7566       };
7567     } catch (std::exception& e) {
7568       {
7569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7570       };
7571     } catch (Dali::DaliException e) {
7572       {
7573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7574       };
7575     } catch (...) {
7576       {
7577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7578       };
7579     }
7580   }
7581
7582   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7583   return jresult;
7584 }
7585
7586
7587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
7588   void * jresult ;
7589   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7590   Dali::Vector4 *arg2 = 0 ;
7591   Dali::Vector4 *result = 0 ;
7592
7593   arg1 = (Dali::Vector4 *)jarg1;
7594   arg2 = (Dali::Vector4 *)jarg2;
7595   if (!arg2) {
7596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7597     return 0;
7598   }
7599   {
7600     try {
7601       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
7602     } catch (std::out_of_range& e) {
7603       {
7604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7605       };
7606     } catch (std::exception& e) {
7607       {
7608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7609       };
7610     } catch (Dali::DaliException e) {
7611       {
7612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7613       };
7614     } catch (...) {
7615       {
7616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7617       };
7618     }
7619   }
7620
7621   jresult = (void *)result;
7622   return jresult;
7623 }
7624
7625
7626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7627   void * jresult ;
7628   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7629   Dali::Vector4 *arg2 = 0 ;
7630   Dali::Vector4 result;
7631
7632   arg1 = (Dali::Vector4 *)jarg1;
7633   arg2 = (Dali::Vector4 *)jarg2;
7634   if (!arg2) {
7635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7636     return 0;
7637   }
7638   {
7639     try {
7640       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7641     } catch (std::out_of_range& e) {
7642       {
7643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7644       };
7645     } catch (std::exception& e) {
7646       {
7647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7648       };
7649     } catch (Dali::DaliException e) {
7650       {
7651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7652       };
7653     } catch (...) {
7654       {
7655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7656       };
7657     }
7658   }
7659
7660   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7661   return jresult;
7662 }
7663
7664
7665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7666   void * jresult ;
7667   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7668   float arg2 ;
7669   Dali::Vector4 result;
7670
7671   arg1 = (Dali::Vector4 *)jarg1;
7672   arg2 = (float)jarg2;
7673   {
7674     try {
7675       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7676     } catch (std::out_of_range& e) {
7677       {
7678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7679       };
7680     } catch (std::exception& e) {
7681       {
7682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7683       };
7684     } catch (Dali::DaliException e) {
7685       {
7686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7687       };
7688     } catch (...) {
7689       {
7690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7691       };
7692     }
7693   }
7694
7695   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7696   return jresult;
7697 }
7698
7699
7700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7701   void * jresult ;
7702   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7703   Dali::Vector4 *arg2 = 0 ;
7704   Dali::Vector4 *result = 0 ;
7705
7706   arg1 = (Dali::Vector4 *)jarg1;
7707   arg2 = (Dali::Vector4 *)jarg2;
7708   if (!arg2) {
7709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7710     return 0;
7711   }
7712   {
7713     try {
7714       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7715     } catch (std::out_of_range& e) {
7716       {
7717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7718       };
7719     } catch (std::exception& e) {
7720       {
7721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7722       };
7723     } catch (Dali::DaliException e) {
7724       {
7725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7726       };
7727     } catch (...) {
7728       {
7729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7730       };
7731     }
7732   }
7733
7734   jresult = (void *)result;
7735   return jresult;
7736 }
7737
7738
7739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7740   void * jresult ;
7741   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7742   float arg2 ;
7743   Dali::Vector4 *result = 0 ;
7744
7745   arg1 = (Dali::Vector4 *)jarg1;
7746   arg2 = (float)jarg2;
7747   {
7748     try {
7749       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7750     } catch (std::out_of_range& e) {
7751       {
7752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7753       };
7754     } catch (std::exception& e) {
7755       {
7756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7757       };
7758     } catch (Dali::DaliException e) {
7759       {
7760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7761       };
7762     } catch (...) {
7763       {
7764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7765       };
7766     }
7767   }
7768
7769   jresult = (void *)result;
7770   return jresult;
7771 }
7772
7773
7774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7775   void * jresult ;
7776   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7777   Dali::Vector4 *arg2 = 0 ;
7778   Dali::Vector4 result;
7779
7780   arg1 = (Dali::Vector4 *)jarg1;
7781   arg2 = (Dali::Vector4 *)jarg2;
7782   if (!arg2) {
7783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7784     return 0;
7785   }
7786   {
7787     try {
7788       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7789     } catch (std::out_of_range& e) {
7790       {
7791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7792       };
7793     } catch (std::exception& e) {
7794       {
7795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7796       };
7797     } catch (Dali::DaliException e) {
7798       {
7799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7800       };
7801     } catch (...) {
7802       {
7803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7804       };
7805     }
7806   }
7807
7808   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7809   return jresult;
7810 }
7811
7812
7813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7814   void * jresult ;
7815   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7816   float arg2 ;
7817   Dali::Vector4 result;
7818
7819   arg1 = (Dali::Vector4 *)jarg1;
7820   arg2 = (float)jarg2;
7821   {
7822     try {
7823       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7824     } catch (std::out_of_range& e) {
7825       {
7826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7827       };
7828     } catch (std::exception& e) {
7829       {
7830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7831       };
7832     } catch (Dali::DaliException e) {
7833       {
7834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7835       };
7836     } catch (...) {
7837       {
7838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7839       };
7840     }
7841   }
7842
7843   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7844   return jresult;
7845 }
7846
7847
7848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7849   void * jresult ;
7850   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7851   Dali::Vector4 *arg2 = 0 ;
7852   Dali::Vector4 *result = 0 ;
7853
7854   arg1 = (Dali::Vector4 *)jarg1;
7855   arg2 = (Dali::Vector4 *)jarg2;
7856   if (!arg2) {
7857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7858     return 0;
7859   }
7860   {
7861     try {
7862       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
7863     } catch (std::out_of_range& e) {
7864       {
7865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7866       };
7867     } catch (std::exception& e) {
7868       {
7869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7870       };
7871     } catch (Dali::DaliException e) {
7872       {
7873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7874       };
7875     } catch (...) {
7876       {
7877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7878       };
7879     }
7880   }
7881
7882   jresult = (void *)result;
7883   return jresult;
7884 }
7885
7886
7887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
7888   void * jresult ;
7889   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7890   float arg2 ;
7891   Dali::Vector4 *result = 0 ;
7892
7893   arg1 = (Dali::Vector4 *)jarg1;
7894   arg2 = (float)jarg2;
7895   {
7896     try {
7897       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
7898     } catch (std::out_of_range& e) {
7899       {
7900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7901       };
7902     } catch (std::exception& e) {
7903       {
7904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7905       };
7906     } catch (Dali::DaliException e) {
7907       {
7908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7909       };
7910     } catch (...) {
7911       {
7912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7913       };
7914     }
7915   }
7916
7917   jresult = (void *)result;
7918   return jresult;
7919 }
7920
7921
7922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
7923   void * jresult ;
7924   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7925   Dali::Vector4 result;
7926
7927   arg1 = (Dali::Vector4 *)jarg1;
7928   {
7929     try {
7930       result = ((Dali::Vector4 const *)arg1)->operator -();
7931     } catch (std::out_of_range& e) {
7932       {
7933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7934       };
7935     } catch (std::exception& e) {
7936       {
7937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7938       };
7939     } catch (Dali::DaliException e) {
7940       {
7941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7942       };
7943     } catch (...) {
7944       {
7945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7946       };
7947     }
7948   }
7949
7950   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7951   return jresult;
7952 }
7953
7954
7955 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
7956   unsigned int jresult ;
7957   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7958   Dali::Vector4 *arg2 = 0 ;
7959   bool result;
7960
7961   arg1 = (Dali::Vector4 *)jarg1;
7962   arg2 = (Dali::Vector4 *)jarg2;
7963   if (!arg2) {
7964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7965     return 0;
7966   }
7967   {
7968     try {
7969       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
7970     } catch (std::out_of_range& e) {
7971       {
7972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7973       };
7974     } catch (std::exception& e) {
7975       {
7976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7977       };
7978     } catch (Dali::DaliException e) {
7979       {
7980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7981       };
7982     } catch (...) {
7983       {
7984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7985       };
7986     }
7987   }
7988
7989   jresult = result;
7990   return jresult;
7991 }
7992
7993
7994 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
7995   unsigned int jresult ;
7996   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7997   Dali::Vector4 *arg2 = 0 ;
7998   bool result;
7999
8000   arg1 = (Dali::Vector4 *)jarg1;
8001   arg2 = (Dali::Vector4 *)jarg2;
8002   if (!arg2) {
8003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8004     return 0;
8005   }
8006   {
8007     try {
8008       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
8009     } catch (std::out_of_range& e) {
8010       {
8011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8012       };
8013     } catch (std::exception& e) {
8014       {
8015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8016       };
8017     } catch (Dali::DaliException e) {
8018       {
8019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8020       };
8021     } catch (...) {
8022       {
8023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8024       };
8025     }
8026   }
8027
8028   jresult = result;
8029   return jresult;
8030 }
8031
8032
8033 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
8034   float jresult ;
8035   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8036   unsigned int arg2 ;
8037   float *result = 0 ;
8038
8039   arg1 = (Dali::Vector4 *)jarg1;
8040   arg2 = (unsigned int)jarg2;
8041   {
8042     try {
8043       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
8044     } catch (std::out_of_range& e) {
8045       {
8046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8047       };
8048     } catch (std::exception& e) {
8049       {
8050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8051       };
8052     } catch (Dali::DaliException e) {
8053       {
8054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8055       };
8056     } catch (...) {
8057       {
8058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8059       };
8060     }
8061   }
8062
8063   jresult = *result;
8064   return jresult;
8065 }
8066
8067
8068 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
8069   float jresult ;
8070   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8071   Dali::Vector3 *arg2 = 0 ;
8072   float result;
8073
8074   arg1 = (Dali::Vector4 *)jarg1;
8075   arg2 = (Dali::Vector3 *)jarg2;
8076   if (!arg2) {
8077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8078     return 0;
8079   }
8080   {
8081     try {
8082       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
8083     } catch (std::out_of_range& e) {
8084       {
8085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8086       };
8087     } catch (std::exception& e) {
8088       {
8089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8090       };
8091     } catch (Dali::DaliException e) {
8092       {
8093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8094       };
8095     } catch (...) {
8096       {
8097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8098       };
8099     }
8100   }
8101
8102   jresult = result;
8103   return jresult;
8104 }
8105
8106
8107 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
8108   float jresult ;
8109   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8110   Dali::Vector4 *arg2 = 0 ;
8111   float result;
8112
8113   arg1 = (Dali::Vector4 *)jarg1;
8114   arg2 = (Dali::Vector4 *)jarg2;
8115   if (!arg2) {
8116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8117     return 0;
8118   }
8119   {
8120     try {
8121       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
8122     } catch (std::out_of_range& e) {
8123       {
8124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8125       };
8126     } catch (std::exception& e) {
8127       {
8128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8129       };
8130     } catch (Dali::DaliException e) {
8131       {
8132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8133       };
8134     } catch (...) {
8135       {
8136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8137       };
8138     }
8139   }
8140
8141   jresult = result;
8142   return jresult;
8143 }
8144
8145
8146 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
8147   float jresult ;
8148   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8149   Dali::Vector4 *arg2 = 0 ;
8150   float result;
8151
8152   arg1 = (Dali::Vector4 *)jarg1;
8153   arg2 = (Dali::Vector4 *)jarg2;
8154   if (!arg2) {
8155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8156     return 0;
8157   }
8158   {
8159     try {
8160       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
8161     } catch (std::out_of_range& e) {
8162       {
8163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8164       };
8165     } catch (std::exception& e) {
8166       {
8167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8168       };
8169     } catch (Dali::DaliException e) {
8170       {
8171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8172       };
8173     } catch (...) {
8174       {
8175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8176       };
8177     }
8178   }
8179
8180   jresult = result;
8181   return jresult;
8182 }
8183
8184
8185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
8186   void * jresult ;
8187   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8188   Dali::Vector4 *arg2 = 0 ;
8189   Dali::Vector4 result;
8190
8191   arg1 = (Dali::Vector4 *)jarg1;
8192   arg2 = (Dali::Vector4 *)jarg2;
8193   if (!arg2) {
8194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8195     return 0;
8196   }
8197   {
8198     try {
8199       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
8200     } catch (std::out_of_range& e) {
8201       {
8202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8203       };
8204     } catch (std::exception& e) {
8205       {
8206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8207       };
8208     } catch (Dali::DaliException e) {
8209       {
8210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8211       };
8212     } catch (...) {
8213       {
8214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8215       };
8216     }
8217   }
8218
8219   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8220   return jresult;
8221 }
8222
8223
8224 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
8225   float jresult ;
8226   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8227   float result;
8228
8229   arg1 = (Dali::Vector4 *)jarg1;
8230   {
8231     try {
8232       result = (float)((Dali::Vector4 const *)arg1)->Length();
8233     } catch (std::out_of_range& e) {
8234       {
8235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8236       };
8237     } catch (std::exception& e) {
8238       {
8239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8240       };
8241     } catch (Dali::DaliException e) {
8242       {
8243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8244       };
8245     } catch (...) {
8246       {
8247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8248       };
8249     }
8250   }
8251
8252   jresult = result;
8253   return jresult;
8254 }
8255
8256
8257 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
8258   float jresult ;
8259   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8260   float result;
8261
8262   arg1 = (Dali::Vector4 *)jarg1;
8263   {
8264     try {
8265       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
8266     } catch (std::out_of_range& e) {
8267       {
8268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8269       };
8270     } catch (std::exception& e) {
8271       {
8272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8273       };
8274     } catch (Dali::DaliException e) {
8275       {
8276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8277       };
8278     } catch (...) {
8279       {
8280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8281       };
8282     }
8283   }
8284
8285   jresult = result;
8286   return jresult;
8287 }
8288
8289
8290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
8291   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8292
8293   arg1 = (Dali::Vector4 *)jarg1;
8294   {
8295     try {
8296       (arg1)->Normalize();
8297     } catch (std::out_of_range& e) {
8298       {
8299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8300       };
8301     } catch (std::exception& e) {
8302       {
8303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8304       };
8305     } catch (Dali::DaliException e) {
8306       {
8307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8308       };
8309     } catch (...) {
8310       {
8311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8312       };
8313     }
8314   }
8315
8316 }
8317
8318
8319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
8320   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8321   Dali::Vector4 *arg2 = 0 ;
8322   Dali::Vector4 *arg3 = 0 ;
8323
8324   arg1 = (Dali::Vector4 *)jarg1;
8325   arg2 = (Dali::Vector4 *)jarg2;
8326   if (!arg2) {
8327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8328     return ;
8329   }
8330   arg3 = (Dali::Vector4 *)jarg3;
8331   if (!arg3) {
8332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8333     return ;
8334   }
8335   {
8336     try {
8337       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
8338     } catch (std::out_of_range& e) {
8339       {
8340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8341       };
8342     } catch (std::exception& e) {
8343       {
8344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8345       };
8346     } catch (Dali::DaliException e) {
8347       {
8348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8349       };
8350     } catch (...) {
8351       {
8352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8353       };
8354     }
8355   }
8356
8357 }
8358
8359
8360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
8361   void * jresult ;
8362   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8363   float *result = 0 ;
8364
8365   arg1 = (Dali::Vector4 *)jarg1;
8366   {
8367     try {
8368       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
8369     } catch (std::out_of_range& e) {
8370       {
8371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8372       };
8373     } catch (std::exception& e) {
8374       {
8375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8376       };
8377     } catch (Dali::DaliException e) {
8378       {
8379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8380       };
8381     } catch (...) {
8382       {
8383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8384       };
8385     }
8386   }
8387
8388   jresult = (void *)result;
8389   return jresult;
8390 }
8391
8392
8393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
8394   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8395   float arg2 ;
8396
8397   arg1 = (Dali::Vector4 *)jarg1;
8398   arg2 = (float)jarg2;
8399   if (arg1) (arg1)->x = arg2;
8400 }
8401
8402
8403 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
8404   float jresult ;
8405   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8406   float result;
8407
8408   arg1 = (Dali::Vector4 *)jarg1;
8409   result = (float) ((arg1)->x);
8410   jresult = result;
8411   return jresult;
8412 }
8413
8414
8415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
8416   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8417   float arg2 ;
8418
8419   arg1 = (Dali::Vector4 *)jarg1;
8420   arg2 = (float)jarg2;
8421   if (arg1) (arg1)->r = arg2;
8422 }
8423
8424
8425 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
8426   float jresult ;
8427   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8428   float result;
8429
8430   arg1 = (Dali::Vector4 *)jarg1;
8431   result = (float) ((arg1)->r);
8432   jresult = result;
8433   return jresult;
8434 }
8435
8436
8437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
8438   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8439   float arg2 ;
8440
8441   arg1 = (Dali::Vector4 *)jarg1;
8442   arg2 = (float)jarg2;
8443   if (arg1) (arg1)->s = arg2;
8444 }
8445
8446
8447 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
8448   float jresult ;
8449   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8450   float result;
8451
8452   arg1 = (Dali::Vector4 *)jarg1;
8453   result = (float) ((arg1)->s);
8454   jresult = result;
8455   return jresult;
8456 }
8457
8458
8459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
8460   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8461   float arg2 ;
8462
8463   arg1 = (Dali::Vector4 *)jarg1;
8464   arg2 = (float)jarg2;
8465   if (arg1) (arg1)->y = arg2;
8466 }
8467
8468
8469 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
8470   float jresult ;
8471   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8472   float result;
8473
8474   arg1 = (Dali::Vector4 *)jarg1;
8475   result = (float) ((arg1)->y);
8476   jresult = result;
8477   return jresult;
8478 }
8479
8480
8481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
8482   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8483   float arg2 ;
8484
8485   arg1 = (Dali::Vector4 *)jarg1;
8486   arg2 = (float)jarg2;
8487   if (arg1) (arg1)->g = arg2;
8488 }
8489
8490
8491 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
8492   float jresult ;
8493   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8494   float result;
8495
8496   arg1 = (Dali::Vector4 *)jarg1;
8497   result = (float) ((arg1)->g);
8498   jresult = result;
8499   return jresult;
8500 }
8501
8502
8503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
8504   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8505   float arg2 ;
8506
8507   arg1 = (Dali::Vector4 *)jarg1;
8508   arg2 = (float)jarg2;
8509   if (arg1) (arg1)->t = arg2;
8510 }
8511
8512
8513 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
8514   float jresult ;
8515   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8516   float result;
8517
8518   arg1 = (Dali::Vector4 *)jarg1;
8519   result = (float) ((arg1)->t);
8520   jresult = result;
8521   return jresult;
8522 }
8523
8524
8525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
8526   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8527   float arg2 ;
8528
8529   arg1 = (Dali::Vector4 *)jarg1;
8530   arg2 = (float)jarg2;
8531   if (arg1) (arg1)->z = arg2;
8532 }
8533
8534
8535 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
8536   float jresult ;
8537   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8538   float result;
8539
8540   arg1 = (Dali::Vector4 *)jarg1;
8541   result = (float) ((arg1)->z);
8542   jresult = result;
8543   return jresult;
8544 }
8545
8546
8547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
8548   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8549   float arg2 ;
8550
8551   arg1 = (Dali::Vector4 *)jarg1;
8552   arg2 = (float)jarg2;
8553   if (arg1) (arg1)->b = arg2;
8554 }
8555
8556
8557 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
8558   float jresult ;
8559   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8560   float result;
8561
8562   arg1 = (Dali::Vector4 *)jarg1;
8563   result = (float) ((arg1)->b);
8564   jresult = result;
8565   return jresult;
8566 }
8567
8568
8569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
8570   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8571   float arg2 ;
8572
8573   arg1 = (Dali::Vector4 *)jarg1;
8574   arg2 = (float)jarg2;
8575   if (arg1) (arg1)->p = arg2;
8576 }
8577
8578
8579 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
8580   float jresult ;
8581   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8582   float result;
8583
8584   arg1 = (Dali::Vector4 *)jarg1;
8585   result = (float) ((arg1)->p);
8586   jresult = result;
8587   return jresult;
8588 }
8589
8590
8591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
8592   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8593   float arg2 ;
8594
8595   arg1 = (Dali::Vector4 *)jarg1;
8596   arg2 = (float)jarg2;
8597   if (arg1) (arg1)->w = arg2;
8598 }
8599
8600
8601 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
8602   float jresult ;
8603   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8604   float result;
8605
8606   arg1 = (Dali::Vector4 *)jarg1;
8607   result = (float) ((arg1)->w);
8608   jresult = result;
8609   return jresult;
8610 }
8611
8612
8613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
8614   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8615   float arg2 ;
8616
8617   arg1 = (Dali::Vector4 *)jarg1;
8618   arg2 = (float)jarg2;
8619   if (arg1) (arg1)->a = arg2;
8620 }
8621
8622
8623 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
8624   float jresult ;
8625   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8626   float result;
8627
8628   arg1 = (Dali::Vector4 *)jarg1;
8629   result = (float) ((arg1)->a);
8630   jresult = result;
8631   return jresult;
8632 }
8633
8634
8635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
8636   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8637   float arg2 ;
8638
8639   arg1 = (Dali::Vector4 *)jarg1;
8640   arg2 = (float)jarg2;
8641   if (arg1) (arg1)->q = arg2;
8642 }
8643
8644
8645 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
8646   float jresult ;
8647   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8648   float result;
8649
8650   arg1 = (Dali::Vector4 *)jarg1;
8651   result = (float) ((arg1)->q);
8652   jresult = result;
8653   return jresult;
8654 }
8655
8656
8657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
8658   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8659
8660   arg1 = (Dali::Vector4 *)jarg1;
8661   {
8662     try {
8663       delete arg1;
8664     } catch (std::out_of_range& e) {
8665       {
8666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8667       };
8668     } catch (std::exception& e) {
8669       {
8670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8671       };
8672     } catch (Dali::DaliException e) {
8673       {
8674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8675       };
8676     } catch (...) {
8677       {
8678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8679       };
8680     }
8681   }
8682
8683 }
8684
8685
8686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
8687   void * jresult ;
8688   Dali::Vector4 *arg1 = 0 ;
8689   Dali::Vector4 *arg2 = 0 ;
8690   Dali::Vector4 result;
8691
8692   arg1 = (Dali::Vector4 *)jarg1;
8693   if (!arg1) {
8694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8695     return 0;
8696   }
8697   arg2 = (Dali::Vector4 *)jarg2;
8698   if (!arg2) {
8699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8700     return 0;
8701   }
8702   {
8703     try {
8704       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8705     } catch (std::out_of_range& e) {
8706       {
8707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8708       };
8709     } catch (std::exception& e) {
8710       {
8711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8712       };
8713     } catch (Dali::DaliException e) {
8714       {
8715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8716       };
8717     } catch (...) {
8718       {
8719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8720       };
8721     }
8722   }
8723
8724   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8725   return jresult;
8726 }
8727
8728
8729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8730   void * jresult ;
8731   Dali::Vector4 *arg1 = 0 ;
8732   Dali::Vector4 *arg2 = 0 ;
8733   Dali::Vector4 result;
8734
8735   arg1 = (Dali::Vector4 *)jarg1;
8736   if (!arg1) {
8737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8738     return 0;
8739   }
8740   arg2 = (Dali::Vector4 *)jarg2;
8741   if (!arg2) {
8742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8743     return 0;
8744   }
8745   {
8746     try {
8747       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8748     } catch (std::out_of_range& e) {
8749       {
8750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8751       };
8752     } catch (std::exception& e) {
8753       {
8754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8755       };
8756     } catch (Dali::DaliException e) {
8757       {
8758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8759       };
8760     } catch (...) {
8761       {
8762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8763       };
8764     }
8765   }
8766
8767   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8768   return jresult;
8769 }
8770
8771
8772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8773   void * jresult ;
8774   Dali::Vector4 *arg1 = 0 ;
8775   float *arg2 = 0 ;
8776   float *arg3 = 0 ;
8777   float temp2 ;
8778   float temp3 ;
8779   Dali::Vector4 result;
8780
8781   arg1 = (Dali::Vector4 *)jarg1;
8782   if (!arg1) {
8783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8784     return 0;
8785   }
8786   temp2 = (float)jarg2;
8787   arg2 = &temp2;
8788   temp3 = (float)jarg3;
8789   arg3 = &temp3;
8790   {
8791     try {
8792       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8793     } catch (std::out_of_range& e) {
8794       {
8795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8796       };
8797     } catch (std::exception& e) {
8798       {
8799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8800       };
8801     } catch (Dali::DaliException e) {
8802       {
8803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8804       };
8805     } catch (...) {
8806       {
8807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8808       };
8809     }
8810   }
8811
8812   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8813   return jresult;
8814 }
8815
8816
8817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8818   void * jresult ;
8819   Dali::Uint16Pair *result = 0 ;
8820
8821   {
8822     try {
8823       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8824     } catch (std::out_of_range& e) {
8825       {
8826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8827       };
8828     } catch (std::exception& e) {
8829       {
8830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8831       };
8832     } catch (Dali::DaliException e) {
8833       {
8834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8835       };
8836     } catch (...) {
8837       {
8838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8839       };
8840     }
8841   }
8842
8843   jresult = (void *)result;
8844   return jresult;
8845 }
8846
8847
8848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8849   void * jresult ;
8850   uint32_t arg1 ;
8851   uint32_t arg2 ;
8852   Dali::Uint16Pair *result = 0 ;
8853
8854   arg1 = (uint32_t)jarg1;
8855   arg2 = (uint32_t)jarg2;
8856   {
8857     try {
8858       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8859     } catch (std::out_of_range& e) {
8860       {
8861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8862       };
8863     } catch (std::exception& e) {
8864       {
8865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8866       };
8867     } catch (Dali::DaliException e) {
8868       {
8869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8870       };
8871     } catch (...) {
8872       {
8873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8874       };
8875     }
8876   }
8877
8878   jresult = (void *)result;
8879   return jresult;
8880 }
8881
8882
8883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
8884   void * jresult ;
8885   Dali::Uint16Pair *arg1 = 0 ;
8886   Dali::Uint16Pair *result = 0 ;
8887
8888   arg1 = (Dali::Uint16Pair *)jarg1;
8889   if (!arg1) {
8890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8891     return 0;
8892   }
8893   {
8894     try {
8895       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
8896     } catch (std::out_of_range& e) {
8897       {
8898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8899       };
8900     } catch (std::exception& e) {
8901       {
8902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8903       };
8904     } catch (Dali::DaliException e) {
8905       {
8906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8907       };
8908     } catch (...) {
8909       {
8910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8911       };
8912     }
8913   }
8914
8915   jresult = (void *)result;
8916   return jresult;
8917 }
8918
8919
8920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
8921   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8922   uint16_t arg2 ;
8923
8924   arg1 = (Dali::Uint16Pair *)jarg1;
8925   arg2 = (uint16_t)jarg2;
8926   {
8927     try {
8928       (arg1)->SetWidth(arg2);
8929     } catch (std::out_of_range& e) {
8930       {
8931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8932       };
8933     } catch (std::exception& e) {
8934       {
8935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8936       };
8937     } catch (Dali::DaliException e) {
8938       {
8939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8940       };
8941     } catch (...) {
8942       {
8943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8944       };
8945     }
8946   }
8947
8948 }
8949
8950
8951 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
8952   unsigned short jresult ;
8953   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8954   uint16_t result;
8955
8956   arg1 = (Dali::Uint16Pair *)jarg1;
8957   {
8958     try {
8959       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
8960     } catch (std::out_of_range& e) {
8961       {
8962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8963       };
8964     } catch (std::exception& e) {
8965       {
8966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8967       };
8968     } catch (Dali::DaliException e) {
8969       {
8970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8971       };
8972     } catch (...) {
8973       {
8974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8975       };
8976     }
8977   }
8978
8979   jresult = result;
8980   return jresult;
8981 }
8982
8983
8984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
8985   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8986   uint16_t arg2 ;
8987
8988   arg1 = (Dali::Uint16Pair *)jarg1;
8989   arg2 = (uint16_t)jarg2;
8990   {
8991     try {
8992       (arg1)->SetHeight(arg2);
8993     } catch (std::out_of_range& e) {
8994       {
8995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8996       };
8997     } catch (std::exception& e) {
8998       {
8999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9000       };
9001     } catch (Dali::DaliException e) {
9002       {
9003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9004       };
9005     } catch (...) {
9006       {
9007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9008       };
9009     }
9010   }
9011
9012 }
9013
9014
9015 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
9016   unsigned short jresult ;
9017   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9018   uint16_t result;
9019
9020   arg1 = (Dali::Uint16Pair *)jarg1;
9021   {
9022     try {
9023       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
9024     } catch (std::out_of_range& e) {
9025       {
9026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9027       };
9028     } catch (std::exception& e) {
9029       {
9030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9031       };
9032     } catch (Dali::DaliException e) {
9033       {
9034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9035       };
9036     } catch (...) {
9037       {
9038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9039       };
9040     }
9041   }
9042
9043   jresult = result;
9044   return jresult;
9045 }
9046
9047
9048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
9049   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9050   uint16_t arg2 ;
9051
9052   arg1 = (Dali::Uint16Pair *)jarg1;
9053   arg2 = (uint16_t)jarg2;
9054   {
9055     try {
9056       (arg1)->SetX(arg2);
9057     } catch (std::out_of_range& e) {
9058       {
9059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9060       };
9061     } catch (std::exception& e) {
9062       {
9063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9064       };
9065     } catch (Dali::DaliException e) {
9066       {
9067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9068       };
9069     } catch (...) {
9070       {
9071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9072       };
9073     }
9074   }
9075
9076 }
9077
9078
9079 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
9080   unsigned short jresult ;
9081   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9082   uint16_t result;
9083
9084   arg1 = (Dali::Uint16Pair *)jarg1;
9085   {
9086     try {
9087       result = ((Dali::Uint16Pair const *)arg1)->GetX();
9088     } catch (std::out_of_range& e) {
9089       {
9090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9091       };
9092     } catch (std::exception& e) {
9093       {
9094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9095       };
9096     } catch (Dali::DaliException e) {
9097       {
9098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9099       };
9100     } catch (...) {
9101       {
9102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9103       };
9104     }
9105   }
9106
9107   jresult = result;
9108   return jresult;
9109 }
9110
9111
9112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
9113   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9114   uint16_t arg2 ;
9115
9116   arg1 = (Dali::Uint16Pair *)jarg1;
9117   arg2 = (uint16_t)jarg2;
9118   {
9119     try {
9120       (arg1)->SetY(arg2);
9121     } catch (std::out_of_range& e) {
9122       {
9123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9124       };
9125     } catch (std::exception& e) {
9126       {
9127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9128       };
9129     } catch (Dali::DaliException e) {
9130       {
9131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9132       };
9133     } catch (...) {
9134       {
9135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9136       };
9137     }
9138   }
9139
9140 }
9141
9142
9143 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
9144   unsigned short jresult ;
9145   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9146   uint16_t result;
9147
9148   arg1 = (Dali::Uint16Pair *)jarg1;
9149   {
9150     try {
9151       result = ((Dali::Uint16Pair const *)arg1)->GetY();
9152     } catch (std::out_of_range& e) {
9153       {
9154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9155       };
9156     } catch (std::exception& e) {
9157       {
9158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9159       };
9160     } catch (Dali::DaliException e) {
9161       {
9162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9163       };
9164     } catch (...) {
9165       {
9166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9167       };
9168     }
9169   }
9170
9171   jresult = result;
9172   return jresult;
9173 }
9174
9175
9176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
9177   void * jresult ;
9178   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9179   Dali::Uint16Pair *arg2 = 0 ;
9180   Dali::Uint16Pair *result = 0 ;
9181
9182   arg1 = (Dali::Uint16Pair *)jarg1;
9183   arg2 = (Dali::Uint16Pair *)jarg2;
9184   if (!arg2) {
9185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9186     return 0;
9187   }
9188   {
9189     try {
9190       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
9191     } catch (std::out_of_range& e) {
9192       {
9193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9194       };
9195     } catch (std::exception& e) {
9196       {
9197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9198       };
9199     } catch (Dali::DaliException e) {
9200       {
9201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9202       };
9203     } catch (...) {
9204       {
9205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9206       };
9207     }
9208   }
9209
9210   jresult = (void *)result;
9211   return jresult;
9212 }
9213
9214
9215 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
9216   unsigned int jresult ;
9217   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9218   Dali::Uint16Pair *arg2 = 0 ;
9219   bool result;
9220
9221   arg1 = (Dali::Uint16Pair *)jarg1;
9222   arg2 = (Dali::Uint16Pair *)jarg2;
9223   if (!arg2) {
9224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9225     return 0;
9226   }
9227   {
9228     try {
9229       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
9230     } catch (std::out_of_range& e) {
9231       {
9232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9233       };
9234     } catch (std::exception& e) {
9235       {
9236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9237       };
9238     } catch (Dali::DaliException e) {
9239       {
9240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9241       };
9242     } catch (...) {
9243       {
9244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9245       };
9246     }
9247   }
9248
9249   jresult = result;
9250   return jresult;
9251 }
9252
9253
9254 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
9255   unsigned int jresult ;
9256   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9257   Dali::Uint16Pair *arg2 = 0 ;
9258   bool result;
9259
9260   arg1 = (Dali::Uint16Pair *)jarg1;
9261   arg2 = (Dali::Uint16Pair *)jarg2;
9262   if (!arg2) {
9263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9264     return 0;
9265   }
9266   {
9267     try {
9268       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
9269     } catch (std::out_of_range& e) {
9270       {
9271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9272       };
9273     } catch (std::exception& e) {
9274       {
9275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9276       };
9277     } catch (Dali::DaliException e) {
9278       {
9279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9280       };
9281     } catch (...) {
9282       {
9283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9284       };
9285     }
9286   }
9287
9288   jresult = result;
9289   return jresult;
9290 }
9291
9292
9293 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
9294   unsigned int jresult ;
9295   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9296   Dali::Uint16Pair *arg2 = 0 ;
9297   bool result;
9298
9299   arg1 = (Dali::Uint16Pair *)jarg1;
9300   arg2 = (Dali::Uint16Pair *)jarg2;
9301   if (!arg2) {
9302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9303     return 0;
9304   }
9305   {
9306     try {
9307       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
9308     } catch (std::out_of_range& e) {
9309       {
9310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9311       };
9312     } catch (std::exception& e) {
9313       {
9314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9315       };
9316     } catch (Dali::DaliException e) {
9317       {
9318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9319       };
9320     } catch (...) {
9321       {
9322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9323       };
9324     }
9325   }
9326
9327   jresult = result;
9328   return jresult;
9329 }
9330
9331
9332 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
9333   unsigned int jresult ;
9334   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9335   Dali::Uint16Pair *arg2 = 0 ;
9336   bool result;
9337
9338   arg1 = (Dali::Uint16Pair *)jarg1;
9339   arg2 = (Dali::Uint16Pair *)jarg2;
9340   if (!arg2) {
9341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9342     return 0;
9343   }
9344   {
9345     try {
9346       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
9347     } catch (std::out_of_range& e) {
9348       {
9349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9350       };
9351     } catch (std::exception& e) {
9352       {
9353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9354       };
9355     } catch (Dali::DaliException e) {
9356       {
9357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9358       };
9359     } catch (...) {
9360       {
9361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9362       };
9363     }
9364   }
9365
9366   jresult = result;
9367   return jresult;
9368 }
9369
9370
9371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
9372   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9373
9374   arg1 = (Dali::Uint16Pair *)jarg1;
9375   {
9376     try {
9377       delete arg1;
9378     } catch (std::out_of_range& e) {
9379       {
9380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9381       };
9382     } catch (std::exception& e) {
9383       {
9384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9385       };
9386     } catch (Dali::DaliException e) {
9387       {
9388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9389       };
9390     } catch (...) {
9391       {
9392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9393       };
9394     }
9395   }
9396
9397 }
9398
9399
9400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
9401   void * jresult ;
9402   Dali::Degree *result = 0 ;
9403
9404   {
9405     try {
9406       result = (Dali::Degree *)new Dali::Degree();
9407     } catch (std::out_of_range& e) {
9408       {
9409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9410       };
9411     } catch (std::exception& e) {
9412       {
9413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9414       };
9415     } catch (Dali::DaliException e) {
9416       {
9417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9418       };
9419     } catch (...) {
9420       {
9421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9422       };
9423     }
9424   }
9425
9426   jresult = (void *)result;
9427   return jresult;
9428 }
9429
9430
9431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
9432   void * jresult ;
9433   float arg1 ;
9434   Dali::Degree *result = 0 ;
9435
9436   arg1 = (float)jarg1;
9437   {
9438     try {
9439       result = (Dali::Degree *)new Dali::Degree(arg1);
9440     } catch (std::out_of_range& e) {
9441       {
9442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9443       };
9444     } catch (std::exception& e) {
9445       {
9446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9447       };
9448     } catch (Dali::DaliException e) {
9449       {
9450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9451       };
9452     } catch (...) {
9453       {
9454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9455       };
9456     }
9457   }
9458
9459   jresult = (void *)result;
9460   return jresult;
9461 }
9462
9463
9464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
9465   void * jresult ;
9466   Dali::Radian arg1 ;
9467   Dali::Radian *argp1 ;
9468   Dali::Degree *result = 0 ;
9469
9470   argp1 = (Dali::Radian *)jarg1;
9471   if (!argp1) {
9472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9473     return 0;
9474   }
9475   arg1 = *argp1;
9476   {
9477     try {
9478       result = (Dali::Degree *)new Dali::Degree(arg1);
9479     } catch (std::out_of_range& e) {
9480       {
9481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9482       };
9483     } catch (std::exception& e) {
9484       {
9485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9486       };
9487     } catch (Dali::DaliException e) {
9488       {
9489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9490       };
9491     } catch (...) {
9492       {
9493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9494       };
9495     }
9496   }
9497
9498   jresult = (void *)result;
9499   return jresult;
9500 }
9501
9502
9503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
9504   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9505   float arg2 ;
9506
9507   arg1 = (Dali::Degree *)jarg1;
9508   arg2 = (float)jarg2;
9509   if (arg1) (arg1)->degree = arg2;
9510 }
9511
9512
9513 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
9514   float jresult ;
9515   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9516   float result;
9517
9518   arg1 = (Dali::Degree *)jarg1;
9519   result = (float) ((arg1)->degree);
9520   jresult = result;
9521   return jresult;
9522 }
9523
9524
9525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
9526   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9527
9528   arg1 = (Dali::Degree *)jarg1;
9529   {
9530     try {
9531       delete arg1;
9532     } catch (std::out_of_range& e) {
9533       {
9534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9535       };
9536     } catch (std::exception& e) {
9537       {
9538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9539       };
9540     } catch (Dali::DaliException e) {
9541       {
9542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9543       };
9544     } catch (...) {
9545       {
9546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9547       };
9548     }
9549   }
9550
9551 }
9552
9553
9554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
9555   void * jresult ;
9556   Dali::Radian *result = 0 ;
9557
9558   result = (Dali::Radian *)&Dali::ANGLE_360;
9559   jresult = (void *)result;
9560   return jresult;
9561 }
9562
9563
9564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
9565   void * jresult ;
9566   Dali::Radian *result = 0 ;
9567
9568   result = (Dali::Radian *)&Dali::ANGLE_315;
9569   jresult = (void *)result;
9570   return jresult;
9571 }
9572
9573
9574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
9575   void * jresult ;
9576   Dali::Radian *result = 0 ;
9577
9578   result = (Dali::Radian *)&Dali::ANGLE_270;
9579   jresult = (void *)result;
9580   return jresult;
9581 }
9582
9583
9584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
9585   void * jresult ;
9586   Dali::Radian *result = 0 ;
9587
9588   result = (Dali::Radian *)&Dali::ANGLE_225;
9589   jresult = (void *)result;
9590   return jresult;
9591 }
9592
9593
9594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
9595   void * jresult ;
9596   Dali::Radian *result = 0 ;
9597
9598   result = (Dali::Radian *)&Dali::ANGLE_180;
9599   jresult = (void *)result;
9600   return jresult;
9601 }
9602
9603
9604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
9605   void * jresult ;
9606   Dali::Radian *result = 0 ;
9607
9608   result = (Dali::Radian *)&Dali::ANGLE_135;
9609   jresult = (void *)result;
9610   return jresult;
9611 }
9612
9613
9614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
9615   void * jresult ;
9616   Dali::Radian *result = 0 ;
9617
9618   result = (Dali::Radian *)&Dali::ANGLE_120;
9619   jresult = (void *)result;
9620   return jresult;
9621 }
9622
9623
9624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
9625   void * jresult ;
9626   Dali::Radian *result = 0 ;
9627
9628   result = (Dali::Radian *)&Dali::ANGLE_90;
9629   jresult = (void *)result;
9630   return jresult;
9631 }
9632
9633
9634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
9635   void * jresult ;
9636   Dali::Radian *result = 0 ;
9637
9638   result = (Dali::Radian *)&Dali::ANGLE_60;
9639   jresult = (void *)result;
9640   return jresult;
9641 }
9642
9643
9644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
9645   void * jresult ;
9646   Dali::Radian *result = 0 ;
9647
9648   result = (Dali::Radian *)&Dali::ANGLE_45;
9649   jresult = (void *)result;
9650   return jresult;
9651 }
9652
9653
9654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
9655   void * jresult ;
9656   Dali::Radian *result = 0 ;
9657
9658   result = (Dali::Radian *)&Dali::ANGLE_30;
9659   jresult = (void *)result;
9660   return jresult;
9661 }
9662
9663
9664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
9665   void * jresult ;
9666   Dali::Radian *result = 0 ;
9667
9668   result = (Dali::Radian *)&Dali::ANGLE_0;
9669   jresult = (void *)result;
9670   return jresult;
9671 }
9672
9673
9674 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
9675   unsigned int jresult ;
9676   Dali::Degree *arg1 = 0 ;
9677   Dali::Degree *arg2 = 0 ;
9678   bool result;
9679
9680   arg1 = (Dali::Degree *)jarg1;
9681   if (!arg1) {
9682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9683     return 0;
9684   }
9685   arg2 = (Dali::Degree *)jarg2;
9686   if (!arg2) {
9687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9688     return 0;
9689   }
9690   {
9691     try {
9692       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9693     } catch (std::out_of_range& e) {
9694       {
9695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9696       };
9697     } catch (std::exception& e) {
9698       {
9699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9700       };
9701     } catch (Dali::DaliException e) {
9702       {
9703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9704       };
9705     } catch (...) {
9706       {
9707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9708       };
9709     }
9710   }
9711
9712   jresult = result;
9713   return jresult;
9714 }
9715
9716
9717 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
9718   unsigned int jresult ;
9719   Dali::Degree *arg1 = 0 ;
9720   Dali::Degree *arg2 = 0 ;
9721   bool result;
9722
9723   arg1 = (Dali::Degree *)jarg1;
9724   if (!arg1) {
9725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9726     return 0;
9727   }
9728   arg2 = (Dali::Degree *)jarg2;
9729   if (!arg2) {
9730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9731     return 0;
9732   }
9733   {
9734     try {
9735       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9736     } catch (std::out_of_range& e) {
9737       {
9738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9739       };
9740     } catch (std::exception& e) {
9741       {
9742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9743       };
9744     } catch (Dali::DaliException e) {
9745       {
9746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9747       };
9748     } catch (...) {
9749       {
9750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9751       };
9752     }
9753   }
9754
9755   jresult = result;
9756   return jresult;
9757 }
9758
9759
9760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
9761   void * jresult ;
9762   Dali::Degree arg1 ;
9763   float arg2 ;
9764   float arg3 ;
9765   Dali::Degree *argp1 ;
9766   Dali::Degree result;
9767
9768   argp1 = (Dali::Degree *)jarg1;
9769   if (!argp1) {
9770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9771     return 0;
9772   }
9773   arg1 = *argp1;
9774   arg2 = (float)jarg2;
9775   arg3 = (float)jarg3;
9776   {
9777     try {
9778       result = Dali::Clamp(arg1,arg2,arg3);
9779     } catch (std::out_of_range& e) {
9780       {
9781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9782       };
9783     } catch (std::exception& e) {
9784       {
9785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9786       };
9787     } catch (Dali::DaliException e) {
9788       {
9789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9790       };
9791     } catch (...) {
9792       {
9793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9794       };
9795     }
9796   }
9797
9798   jresult = new Dali::Degree((const Dali::Degree &)result);
9799   return jresult;
9800 }
9801
9802
9803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
9804   void * jresult ;
9805   Dali::Radian *result = 0 ;
9806
9807   {
9808     try {
9809       result = (Dali::Radian *)new Dali::Radian();
9810     } catch (std::out_of_range& e) {
9811       {
9812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9813       };
9814     } catch (std::exception& e) {
9815       {
9816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9817       };
9818     } catch (Dali::DaliException e) {
9819       {
9820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9821       };
9822     } catch (...) {
9823       {
9824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9825       };
9826     }
9827   }
9828
9829   jresult = (void *)result;
9830   return jresult;
9831 }
9832
9833
9834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
9835   void * jresult ;
9836   float arg1 ;
9837   Dali::Radian *result = 0 ;
9838
9839   arg1 = (float)jarg1;
9840   {
9841     try {
9842       result = (Dali::Radian *)new Dali::Radian(arg1);
9843     } catch (std::out_of_range& e) {
9844       {
9845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9846       };
9847     } catch (std::exception& e) {
9848       {
9849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9850       };
9851     } catch (Dali::DaliException e) {
9852       {
9853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9854       };
9855     } catch (...) {
9856       {
9857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9858       };
9859     }
9860   }
9861
9862   jresult = (void *)result;
9863   return jresult;
9864 }
9865
9866
9867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
9868   void * jresult ;
9869   Dali::Degree arg1 ;
9870   Dali::Degree *argp1 ;
9871   Dali::Radian *result = 0 ;
9872
9873   argp1 = (Dali::Degree *)jarg1;
9874   if (!argp1) {
9875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9876     return 0;
9877   }
9878   arg1 = *argp1;
9879   {
9880     try {
9881       result = (Dali::Radian *)new Dali::Radian(arg1);
9882     } catch (std::out_of_range& e) {
9883       {
9884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9885       };
9886     } catch (std::exception& e) {
9887       {
9888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9889       };
9890     } catch (Dali::DaliException e) {
9891       {
9892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9893       };
9894     } catch (...) {
9895       {
9896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9897       };
9898     }
9899   }
9900
9901   jresult = (void *)result;
9902   return jresult;
9903 }
9904
9905
9906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
9907   void * jresult ;
9908   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9909   float arg2 ;
9910   Dali::Radian *result = 0 ;
9911
9912   arg1 = (Dali::Radian *)jarg1;
9913   arg2 = (float)jarg2;
9914   {
9915     try {
9916       result = (Dali::Radian *) &(arg1)->operator =(arg2);
9917     } catch (std::out_of_range& e) {
9918       {
9919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9920       };
9921     } catch (std::exception& e) {
9922       {
9923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9924       };
9925     } catch (Dali::DaliException e) {
9926       {
9927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9928       };
9929     } catch (...) {
9930       {
9931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9932       };
9933     }
9934   }
9935
9936   jresult = (void *)result;
9937   return jresult;
9938 }
9939
9940
9941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
9942   void * jresult ;
9943   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9944   Dali::Degree arg2 ;
9945   Dali::Degree *argp2 ;
9946   Dali::Radian *result = 0 ;
9947
9948   arg1 = (Dali::Radian *)jarg1;
9949   argp2 = (Dali::Degree *)jarg2;
9950   if (!argp2) {
9951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9952     return 0;
9953   }
9954   arg2 = *argp2;
9955   {
9956     try {
9957       result = (Dali::Radian *) &(arg1)->operator =(arg2);
9958     } catch (std::out_of_range& e) {
9959       {
9960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9961       };
9962     } catch (std::exception& e) {
9963       {
9964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9965       };
9966     } catch (Dali::DaliException e) {
9967       {
9968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9969       };
9970     } catch (...) {
9971       {
9972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9973       };
9974     }
9975   }
9976
9977   jresult = (void *)result;
9978   return jresult;
9979 }
9980
9981
9982 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
9983   float jresult ;
9984   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9985   float result;
9986
9987   arg1 = (Dali::Radian *)jarg1;
9988   {
9989     try {
9990       result = (float)((Dali::Radian const *)arg1)->operator float();
9991     } catch (std::out_of_range& e) {
9992       {
9993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9994       };
9995     } catch (std::exception& e) {
9996       {
9997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9998       };
9999     } catch (Dali::DaliException e) {
10000       {
10001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10002       };
10003     } catch (...) {
10004       {
10005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10006       };
10007     }
10008   }
10009
10010   jresult = result;
10011   return jresult;
10012 }
10013
10014
10015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
10016   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10017   float arg2 ;
10018
10019   arg1 = (Dali::Radian *)jarg1;
10020   arg2 = (float)jarg2;
10021   if (arg1) (arg1)->radian = arg2;
10022 }
10023
10024
10025 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
10026   float jresult ;
10027   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10028   float result;
10029
10030   arg1 = (Dali::Radian *)jarg1;
10031   result = (float) ((arg1)->radian);
10032   jresult = result;
10033   return jresult;
10034 }
10035
10036
10037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
10038   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10039
10040   arg1 = (Dali::Radian *)jarg1;
10041   {
10042     try {
10043       delete arg1;
10044     } catch (std::out_of_range& e) {
10045       {
10046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10047       };
10048     } catch (std::exception& e) {
10049       {
10050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10051       };
10052     } catch (Dali::DaliException e) {
10053       {
10054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10055       };
10056     } catch (...) {
10057       {
10058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10059       };
10060     }
10061   }
10062
10063 }
10064
10065
10066 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
10067   unsigned int jresult ;
10068   Dali::Radian arg1 ;
10069   Dali::Radian arg2 ;
10070   Dali::Radian *argp1 ;
10071   Dali::Radian *argp2 ;
10072   bool result;
10073
10074   argp1 = (Dali::Radian *)jarg1;
10075   if (!argp1) {
10076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10077     return 0;
10078   }
10079   arg1 = *argp1;
10080   argp2 = (Dali::Radian *)jarg2;
10081   if (!argp2) {
10082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10083     return 0;
10084   }
10085   arg2 = *argp2;
10086   {
10087     try {
10088       result = (bool)Dali::operator ==(arg1,arg2);
10089     } catch (std::out_of_range& e) {
10090       {
10091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10092       };
10093     } catch (std::exception& e) {
10094       {
10095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10096       };
10097     } catch (Dali::DaliException e) {
10098       {
10099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10100       };
10101     } catch (...) {
10102       {
10103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10104       };
10105     }
10106   }
10107
10108   jresult = result;
10109   return jresult;
10110 }
10111
10112
10113 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
10114   unsigned int jresult ;
10115   Dali::Radian arg1 ;
10116   Dali::Radian arg2 ;
10117   Dali::Radian *argp1 ;
10118   Dali::Radian *argp2 ;
10119   bool result;
10120
10121   argp1 = (Dali::Radian *)jarg1;
10122   if (!argp1) {
10123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10124     return 0;
10125   }
10126   arg1 = *argp1;
10127   argp2 = (Dali::Radian *)jarg2;
10128   if (!argp2) {
10129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10130     return 0;
10131   }
10132   arg2 = *argp2;
10133   {
10134     try {
10135       result = (bool)Dali::operator !=(arg1,arg2);
10136     } catch (std::out_of_range& e) {
10137       {
10138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10139       };
10140     } catch (std::exception& e) {
10141       {
10142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10143       };
10144     } catch (Dali::DaliException e) {
10145       {
10146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10147       };
10148     } catch (...) {
10149       {
10150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10151       };
10152     }
10153   }
10154
10155   jresult = result;
10156   return jresult;
10157 }
10158
10159
10160 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
10161   unsigned int jresult ;
10162   Dali::Radian arg1 ;
10163   Dali::Degree arg2 ;
10164   Dali::Radian *argp1 ;
10165   Dali::Degree *argp2 ;
10166   bool result;
10167
10168   argp1 = (Dali::Radian *)jarg1;
10169   if (!argp1) {
10170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10171     return 0;
10172   }
10173   arg1 = *argp1;
10174   argp2 = (Dali::Degree *)jarg2;
10175   if (!argp2) {
10176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10177     return 0;
10178   }
10179   arg2 = *argp2;
10180   {
10181     try {
10182       result = (bool)Dali::operator ==(arg1,arg2);
10183     } catch (std::out_of_range& e) {
10184       {
10185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10186       };
10187     } catch (std::exception& e) {
10188       {
10189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10190       };
10191     } catch (Dali::DaliException e) {
10192       {
10193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10194       };
10195     } catch (...) {
10196       {
10197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10198       };
10199     }
10200   }
10201
10202   jresult = result;
10203   return jresult;
10204 }
10205
10206
10207 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
10208   unsigned int jresult ;
10209   Dali::Radian arg1 ;
10210   Dali::Degree arg2 ;
10211   Dali::Radian *argp1 ;
10212   Dali::Degree *argp2 ;
10213   bool result;
10214
10215   argp1 = (Dali::Radian *)jarg1;
10216   if (!argp1) {
10217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10218     return 0;
10219   }
10220   arg1 = *argp1;
10221   argp2 = (Dali::Degree *)jarg2;
10222   if (!argp2) {
10223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10224     return 0;
10225   }
10226   arg2 = *argp2;
10227   {
10228     try {
10229       result = (bool)Dali::operator !=(arg1,arg2);
10230     } catch (std::out_of_range& e) {
10231       {
10232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10233       };
10234     } catch (std::exception& e) {
10235       {
10236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10237       };
10238     } catch (Dali::DaliException e) {
10239       {
10240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10241       };
10242     } catch (...) {
10243       {
10244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10245       };
10246     }
10247   }
10248
10249   jresult = result;
10250   return jresult;
10251 }
10252
10253
10254 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
10255   unsigned int jresult ;
10256   Dali::Degree arg1 ;
10257   Dali::Radian arg2 ;
10258   Dali::Degree *argp1 ;
10259   Dali::Radian *argp2 ;
10260   bool result;
10261
10262   argp1 = (Dali::Degree *)jarg1;
10263   if (!argp1) {
10264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10265     return 0;
10266   }
10267   arg1 = *argp1;
10268   argp2 = (Dali::Radian *)jarg2;
10269   if (!argp2) {
10270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10271     return 0;
10272   }
10273   arg2 = *argp2;
10274   {
10275     try {
10276       result = (bool)Dali::operator ==(arg1,arg2);
10277     } catch (std::out_of_range& e) {
10278       {
10279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10280       };
10281     } catch (std::exception& e) {
10282       {
10283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10284       };
10285     } catch (Dali::DaliException e) {
10286       {
10287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10288       };
10289     } catch (...) {
10290       {
10291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10292       };
10293     }
10294   }
10295
10296   jresult = result;
10297   return jresult;
10298 }
10299
10300
10301 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
10302   unsigned int jresult ;
10303   Dali::Degree arg1 ;
10304   Dali::Radian arg2 ;
10305   Dali::Degree *argp1 ;
10306   Dali::Radian *argp2 ;
10307   bool result;
10308
10309   argp1 = (Dali::Degree *)jarg1;
10310   if (!argp1) {
10311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10312     return 0;
10313   }
10314   arg1 = *argp1;
10315   argp2 = (Dali::Radian *)jarg2;
10316   if (!argp2) {
10317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10318     return 0;
10319   }
10320   arg2 = *argp2;
10321   {
10322     try {
10323       result = (bool)Dali::operator !=(arg1,arg2);
10324     } catch (std::out_of_range& e) {
10325       {
10326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10327       };
10328     } catch (std::exception& e) {
10329       {
10330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10331       };
10332     } catch (Dali::DaliException e) {
10333       {
10334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10335       };
10336     } catch (...) {
10337       {
10338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10339       };
10340     }
10341   }
10342
10343   jresult = result;
10344   return jresult;
10345 }
10346
10347
10348 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
10349   unsigned int jresult ;
10350   Dali::Radian arg1 ;
10351   Dali::Radian arg2 ;
10352   Dali::Radian *argp1 ;
10353   Dali::Radian *argp2 ;
10354   bool result;
10355
10356   argp1 = (Dali::Radian *)jarg1;
10357   if (!argp1) {
10358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10359     return 0;
10360   }
10361   arg1 = *argp1;
10362   argp2 = (Dali::Radian *)jarg2;
10363   if (!argp2) {
10364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10365     return 0;
10366   }
10367   arg2 = *argp2;
10368   {
10369     try {
10370       result = (bool)Dali::operator >(arg1,arg2);
10371     } catch (std::out_of_range& e) {
10372       {
10373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10374       };
10375     } catch (std::exception& e) {
10376       {
10377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10378       };
10379     } catch (Dali::DaliException e) {
10380       {
10381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10382       };
10383     } catch (...) {
10384       {
10385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10386       };
10387     }
10388   }
10389
10390   jresult = result;
10391   return jresult;
10392 }
10393
10394
10395 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
10396   unsigned int jresult ;
10397   Dali::Radian arg1 ;
10398   Dali::Degree arg2 ;
10399   Dali::Radian *argp1 ;
10400   Dali::Degree *argp2 ;
10401   bool result;
10402
10403   argp1 = (Dali::Radian *)jarg1;
10404   if (!argp1) {
10405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10406     return 0;
10407   }
10408   arg1 = *argp1;
10409   argp2 = (Dali::Degree *)jarg2;
10410   if (!argp2) {
10411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10412     return 0;
10413   }
10414   arg2 = *argp2;
10415   {
10416     try {
10417       result = (bool)Dali::operator >(arg1,arg2);
10418     } catch (std::out_of_range& e) {
10419       {
10420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10421       };
10422     } catch (std::exception& e) {
10423       {
10424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10425       };
10426     } catch (Dali::DaliException e) {
10427       {
10428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10429       };
10430     } catch (...) {
10431       {
10432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10433       };
10434     }
10435   }
10436
10437   jresult = result;
10438   return jresult;
10439 }
10440
10441
10442 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
10443   unsigned int jresult ;
10444   Dali::Degree arg1 ;
10445   Dali::Radian arg2 ;
10446   Dali::Degree *argp1 ;
10447   Dali::Radian *argp2 ;
10448   bool result;
10449
10450   argp1 = (Dali::Degree *)jarg1;
10451   if (!argp1) {
10452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10453     return 0;
10454   }
10455   arg1 = *argp1;
10456   argp2 = (Dali::Radian *)jarg2;
10457   if (!argp2) {
10458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10459     return 0;
10460   }
10461   arg2 = *argp2;
10462   {
10463     try {
10464       result = (bool)Dali::operator >(arg1,arg2);
10465     } catch (std::out_of_range& e) {
10466       {
10467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10468       };
10469     } catch (std::exception& e) {
10470       {
10471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10472       };
10473     } catch (Dali::DaliException e) {
10474       {
10475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10476       };
10477     } catch (...) {
10478       {
10479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10480       };
10481     }
10482   }
10483
10484   jresult = result;
10485   return jresult;
10486 }
10487
10488
10489 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
10490   unsigned int jresult ;
10491   Dali::Radian arg1 ;
10492   Dali::Radian arg2 ;
10493   Dali::Radian *argp1 ;
10494   Dali::Radian *argp2 ;
10495   bool result;
10496
10497   argp1 = (Dali::Radian *)jarg1;
10498   if (!argp1) {
10499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10500     return 0;
10501   }
10502   arg1 = *argp1;
10503   argp2 = (Dali::Radian *)jarg2;
10504   if (!argp2) {
10505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10506     return 0;
10507   }
10508   arg2 = *argp2;
10509   {
10510     try {
10511       result = (bool)Dali::operator <(arg1,arg2);
10512     } catch (std::out_of_range& e) {
10513       {
10514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10515       };
10516     } catch (std::exception& e) {
10517       {
10518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10519       };
10520     } catch (Dali::DaliException e) {
10521       {
10522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10523       };
10524     } catch (...) {
10525       {
10526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10527       };
10528     }
10529   }
10530
10531   jresult = result;
10532   return jresult;
10533 }
10534
10535
10536 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
10537   unsigned int jresult ;
10538   Dali::Radian arg1 ;
10539   Dali::Degree arg2 ;
10540   Dali::Radian *argp1 ;
10541   Dali::Degree *argp2 ;
10542   bool result;
10543
10544   argp1 = (Dali::Radian *)jarg1;
10545   if (!argp1) {
10546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10547     return 0;
10548   }
10549   arg1 = *argp1;
10550   argp2 = (Dali::Degree *)jarg2;
10551   if (!argp2) {
10552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10553     return 0;
10554   }
10555   arg2 = *argp2;
10556   {
10557     try {
10558       result = (bool)Dali::operator <(arg1,arg2);
10559     } catch (std::out_of_range& e) {
10560       {
10561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10562       };
10563     } catch (std::exception& e) {
10564       {
10565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10566       };
10567     } catch (Dali::DaliException e) {
10568       {
10569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10570       };
10571     } catch (...) {
10572       {
10573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10574       };
10575     }
10576   }
10577
10578   jresult = result;
10579   return jresult;
10580 }
10581
10582
10583 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
10584   unsigned int jresult ;
10585   Dali::Degree arg1 ;
10586   Dali::Radian arg2 ;
10587   Dali::Degree *argp1 ;
10588   Dali::Radian *argp2 ;
10589   bool result;
10590
10591   argp1 = (Dali::Degree *)jarg1;
10592   if (!argp1) {
10593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10594     return 0;
10595   }
10596   arg1 = *argp1;
10597   argp2 = (Dali::Radian *)jarg2;
10598   if (!argp2) {
10599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10600     return 0;
10601   }
10602   arg2 = *argp2;
10603   {
10604     try {
10605       result = (bool)Dali::operator <(arg1,arg2);
10606     } catch (std::out_of_range& e) {
10607       {
10608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10609       };
10610     } catch (std::exception& e) {
10611       {
10612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10613       };
10614     } catch (Dali::DaliException e) {
10615       {
10616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10617       };
10618     } catch (...) {
10619       {
10620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10621       };
10622     }
10623   }
10624
10625   jresult = result;
10626   return jresult;
10627 }
10628
10629
10630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
10631   void * jresult ;
10632   Dali::Radian arg1 ;
10633   float arg2 ;
10634   Dali::Radian *argp1 ;
10635   Dali::Radian result;
10636
10637   argp1 = (Dali::Radian *)jarg1;
10638   if (!argp1) {
10639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10640     return 0;
10641   }
10642   arg1 = *argp1;
10643   arg2 = (float)jarg2;
10644   {
10645     try {
10646       result = Dali::operator *(arg1,arg2);
10647     } catch (std::out_of_range& e) {
10648       {
10649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10650       };
10651     } catch (std::exception& e) {
10652       {
10653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10654       };
10655     } catch (Dali::DaliException e) {
10656       {
10657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10658       };
10659     } catch (...) {
10660       {
10661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10662       };
10663     }
10664   }
10665
10666   jresult = new Dali::Radian((const Dali::Radian &)result);
10667   return jresult;
10668 }
10669
10670
10671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
10672   void * jresult ;
10673   Dali::Radian arg1 ;
10674   Dali::Radian *argp1 ;
10675   Dali::Radian result;
10676
10677   argp1 = (Dali::Radian *)jarg1;
10678   if (!argp1) {
10679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10680     return 0;
10681   }
10682   arg1 = *argp1;
10683   {
10684     try {
10685       result = Dali::operator -(arg1);
10686     } catch (std::out_of_range& e) {
10687       {
10688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10689       };
10690     } catch (std::exception& e) {
10691       {
10692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10693       };
10694     } catch (Dali::DaliException e) {
10695       {
10696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10697       };
10698     } catch (...) {
10699       {
10700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10701       };
10702     }
10703   }
10704
10705   jresult = new Dali::Radian((const Dali::Radian &)result);
10706   return jresult;
10707 }
10708
10709
10710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
10711   void * jresult ;
10712   Dali::Radian arg1 ;
10713   float arg2 ;
10714   float arg3 ;
10715   Dali::Radian *argp1 ;
10716   Dali::Radian result;
10717
10718   argp1 = (Dali::Radian *)jarg1;
10719   if (!argp1) {
10720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10721     return 0;
10722   }
10723   arg1 = *argp1;
10724   arg2 = (float)jarg2;
10725   arg3 = (float)jarg3;
10726   {
10727     try {
10728       result = Dali::Clamp(arg1,arg2,arg3);
10729     } catch (std::out_of_range& e) {
10730       {
10731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10732       };
10733     } catch (std::exception& e) {
10734       {
10735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10736       };
10737     } catch (Dali::DaliException e) {
10738       {
10739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10740       };
10741     } catch (...) {
10742       {
10743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10744       };
10745     }
10746   }
10747
10748   jresult = new Dali::Radian((const Dali::Radian &)result);
10749   return jresult;
10750 }
10751
10752
10753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
10754   void * jresult ;
10755   Dali::Quaternion *result = 0 ;
10756
10757   {
10758     try {
10759       result = (Dali::Quaternion *)new Dali::Quaternion();
10760     } catch (std::out_of_range& e) {
10761       {
10762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10763       };
10764     } catch (std::exception& e) {
10765       {
10766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10767       };
10768     } catch (Dali::DaliException e) {
10769       {
10770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10771       };
10772     } catch (...) {
10773       {
10774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10775       };
10776     }
10777   }
10778
10779   jresult = (void *)result;
10780   return jresult;
10781 }
10782
10783
10784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
10785   void * jresult ;
10786   Dali::Radian arg1 ;
10787   Dali::Vector3 *arg2 = 0 ;
10788   Dali::Radian *argp1 ;
10789   Dali::Quaternion *result = 0 ;
10790
10791   argp1 = (Dali::Radian *)jarg1;
10792   if (!argp1) {
10793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10794     return 0;
10795   }
10796   arg1 = *argp1;
10797   arg2 = (Dali::Vector3 *)jarg2;
10798   if (!arg2) {
10799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10800     return 0;
10801   }
10802   {
10803     try {
10804       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
10805     } catch (std::out_of_range& e) {
10806       {
10807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10808       };
10809     } catch (std::exception& e) {
10810       {
10811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10812       };
10813     } catch (Dali::DaliException e) {
10814       {
10815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10816       };
10817     } catch (...) {
10818       {
10819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10820       };
10821     }
10822   }
10823
10824   jresult = (void *)result;
10825   return jresult;
10826 }
10827
10828
10829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
10830   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10831
10832   arg1 = (Dali::Quaternion *)jarg1;
10833   {
10834     try {
10835       delete arg1;
10836     } catch (std::out_of_range& e) {
10837       {
10838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10839       };
10840     } catch (std::exception& e) {
10841       {
10842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10843       };
10844     } catch (Dali::DaliException e) {
10845       {
10846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10847       };
10848     } catch (...) {
10849       {
10850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10851       };
10852     }
10853   }
10854
10855 }
10856
10857
10858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
10859   void * jresult ;
10860   Dali::Quaternion *result = 0 ;
10861
10862   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
10863   jresult = (void *)result;
10864   return jresult;
10865 }
10866
10867
10868 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
10869   unsigned int jresult ;
10870   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10871   bool result;
10872
10873   arg1 = (Dali::Quaternion *)jarg1;
10874   {
10875     try {
10876       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
10877     } catch (std::out_of_range& e) {
10878       {
10879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10880       };
10881     } catch (std::exception& e) {
10882       {
10883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10884       };
10885     } catch (Dali::DaliException e) {
10886       {
10887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10888       };
10889     } catch (...) {
10890       {
10891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10892       };
10893     }
10894   }
10895
10896   jresult = result;
10897   return jresult;
10898 }
10899
10900
10901 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
10902   unsigned int jresult ;
10903   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10904   Dali::Vector3 *arg2 = 0 ;
10905   Dali::Radian *arg3 = 0 ;
10906   bool result;
10907
10908   arg1 = (Dali::Quaternion *)jarg1;
10909   arg2 = (Dali::Vector3 *)jarg2;
10910   if (!arg2) {
10911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
10912     return 0;
10913   }
10914   arg3 = (Dali::Radian *)jarg3;
10915   if (!arg3) {
10916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
10917     return 0;
10918   }
10919   {
10920     try {
10921       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
10922     } catch (std::out_of_range& e) {
10923       {
10924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10925       };
10926     } catch (std::exception& e) {
10927       {
10928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10929       };
10930     } catch (Dali::DaliException e) {
10931       {
10932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10933       };
10934     } catch (...) {
10935       {
10936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10937       };
10938     }
10939   }
10940
10941   jresult = result;
10942   return jresult;
10943 }
10944
10945
10946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
10947   void * jresult ;
10948   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10949   Dali::Quaternion *arg2 = 0 ;
10950   Dali::Quaternion result;
10951
10952   arg1 = (Dali::Quaternion *)jarg1;
10953   arg2 = (Dali::Quaternion *)jarg2;
10954   if (!arg2) {
10955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10956     return 0;
10957   }
10958   {
10959     try {
10960       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
10961     } catch (std::out_of_range& e) {
10962       {
10963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10964       };
10965     } catch (std::exception& e) {
10966       {
10967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10968       };
10969     } catch (Dali::DaliException e) {
10970       {
10971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10972       };
10973     } catch (...) {
10974       {
10975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10976       };
10977     }
10978   }
10979
10980   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10981   return jresult;
10982 }
10983
10984
10985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
10986   void * jresult ;
10987   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10988   Dali::Quaternion *arg2 = 0 ;
10989   Dali::Quaternion result;
10990
10991   arg1 = (Dali::Quaternion *)jarg1;
10992   arg2 = (Dali::Quaternion *)jarg2;
10993   if (!arg2) {
10994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10995     return 0;
10996   }
10997   {
10998     try {
10999       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
11000     } catch (std::out_of_range& e) {
11001       {
11002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11003       };
11004     } catch (std::exception& e) {
11005       {
11006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11007       };
11008     } catch (Dali::DaliException e) {
11009       {
11010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11011       };
11012     } catch (...) {
11013       {
11014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11015       };
11016     }
11017   }
11018
11019   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11020   return jresult;
11021 }
11022
11023
11024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
11025   void * jresult ;
11026   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11027   Dali::Quaternion *arg2 = 0 ;
11028   Dali::Quaternion result;
11029
11030   arg1 = (Dali::Quaternion *)jarg1;
11031   arg2 = (Dali::Quaternion *)jarg2;
11032   if (!arg2) {
11033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11034     return 0;
11035   }
11036   {
11037     try {
11038       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
11039     } catch (std::out_of_range& e) {
11040       {
11041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11042       };
11043     } catch (std::exception& e) {
11044       {
11045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11046       };
11047     } catch (Dali::DaliException e) {
11048       {
11049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11050       };
11051     } catch (...) {
11052       {
11053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11054       };
11055     }
11056   }
11057
11058   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11059   return jresult;
11060 }
11061
11062
11063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
11064   void * jresult ;
11065   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11066   Dali::Vector3 *arg2 = 0 ;
11067   Dali::Vector3 result;
11068
11069   arg1 = (Dali::Quaternion *)jarg1;
11070   arg2 = (Dali::Vector3 *)jarg2;
11071   if (!arg2) {
11072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11073     return 0;
11074   }
11075   {
11076     try {
11077       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
11078     } catch (std::out_of_range& e) {
11079       {
11080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11081       };
11082     } catch (std::exception& e) {
11083       {
11084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11085       };
11086     } catch (Dali::DaliException e) {
11087       {
11088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11089       };
11090     } catch (...) {
11091       {
11092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11093       };
11094     }
11095   }
11096
11097   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11098   return jresult;
11099 }
11100
11101
11102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
11103   void * jresult ;
11104   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11105   Dali::Quaternion *arg2 = 0 ;
11106   Dali::Quaternion result;
11107
11108   arg1 = (Dali::Quaternion *)jarg1;
11109   arg2 = (Dali::Quaternion *)jarg2;
11110   if (!arg2) {
11111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11112     return 0;
11113   }
11114   {
11115     try {
11116       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
11117     } catch (std::out_of_range& e) {
11118       {
11119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11120       };
11121     } catch (std::exception& e) {
11122       {
11123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11124       };
11125     } catch (Dali::DaliException e) {
11126       {
11127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11128       };
11129     } catch (...) {
11130       {
11131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11132       };
11133     }
11134   }
11135
11136   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11137   return jresult;
11138 }
11139
11140
11141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
11142   void * jresult ;
11143   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11144   float arg2 ;
11145   Dali::Quaternion result;
11146
11147   arg1 = (Dali::Quaternion *)jarg1;
11148   arg2 = (float)jarg2;
11149   {
11150     try {
11151       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
11152     } catch (std::out_of_range& e) {
11153       {
11154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11155       };
11156     } catch (std::exception& e) {
11157       {
11158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11159       };
11160     } catch (Dali::DaliException e) {
11161       {
11162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11163       };
11164     } catch (...) {
11165       {
11166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11167       };
11168     }
11169   }
11170
11171   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11172   return jresult;
11173 }
11174
11175
11176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
11177   void * jresult ;
11178   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11179   float arg2 ;
11180   Dali::Quaternion result;
11181
11182   arg1 = (Dali::Quaternion *)jarg1;
11183   arg2 = (float)jarg2;
11184   {
11185     try {
11186       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
11187     } catch (std::out_of_range& e) {
11188       {
11189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11190       };
11191     } catch (std::exception& e) {
11192       {
11193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11194       };
11195     } catch (Dali::DaliException e) {
11196       {
11197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11198       };
11199     } catch (...) {
11200       {
11201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11202       };
11203     }
11204   }
11205
11206   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11207   return jresult;
11208 }
11209
11210
11211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
11212   void * jresult ;
11213   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11214   Dali::Quaternion result;
11215
11216   arg1 = (Dali::Quaternion *)jarg1;
11217   {
11218     try {
11219       result = ((Dali::Quaternion const *)arg1)->operator -();
11220     } catch (std::out_of_range& e) {
11221       {
11222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11223       };
11224     } catch (std::exception& e) {
11225       {
11226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11227       };
11228     } catch (Dali::DaliException e) {
11229       {
11230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11231       };
11232     } catch (...) {
11233       {
11234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11235       };
11236     }
11237   }
11238
11239   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11240   return jresult;
11241 }
11242
11243
11244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
11245   void * jresult ;
11246   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11247   Dali::Quaternion *arg2 = 0 ;
11248   Dali::Quaternion *result = 0 ;
11249
11250   arg1 = (Dali::Quaternion *)jarg1;
11251   arg2 = (Dali::Quaternion *)jarg2;
11252   if (!arg2) {
11253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11254     return 0;
11255   }
11256   {
11257     try {
11258       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
11259     } catch (std::out_of_range& e) {
11260       {
11261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11262       };
11263     } catch (std::exception& e) {
11264       {
11265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11266       };
11267     } catch (Dali::DaliException e) {
11268       {
11269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11270       };
11271     } catch (...) {
11272       {
11273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11274       };
11275     }
11276   }
11277
11278   jresult = (void *)result;
11279   return jresult;
11280 }
11281
11282
11283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
11284   void * jresult ;
11285   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11286   Dali::Quaternion *arg2 = 0 ;
11287   Dali::Quaternion *result = 0 ;
11288
11289   arg1 = (Dali::Quaternion *)jarg1;
11290   arg2 = (Dali::Quaternion *)jarg2;
11291   if (!arg2) {
11292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11293     return 0;
11294   }
11295   {
11296     try {
11297       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
11298     } catch (std::out_of_range& e) {
11299       {
11300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11301       };
11302     } catch (std::exception& e) {
11303       {
11304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11305       };
11306     } catch (Dali::DaliException e) {
11307       {
11308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11309       };
11310     } catch (...) {
11311       {
11312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11313       };
11314     }
11315   }
11316
11317   jresult = (void *)result;
11318   return jresult;
11319 }
11320
11321
11322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
11323   void * jresult ;
11324   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11325   Dali::Quaternion *arg2 = 0 ;
11326   Dali::Quaternion *result = 0 ;
11327
11328   arg1 = (Dali::Quaternion *)jarg1;
11329   arg2 = (Dali::Quaternion *)jarg2;
11330   if (!arg2) {
11331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11332     return 0;
11333   }
11334   {
11335     try {
11336       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
11337     } catch (std::out_of_range& e) {
11338       {
11339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11340       };
11341     } catch (std::exception& e) {
11342       {
11343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11344       };
11345     } catch (Dali::DaliException e) {
11346       {
11347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11348       };
11349     } catch (...) {
11350       {
11351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11352       };
11353     }
11354   }
11355
11356   jresult = (void *)result;
11357   return jresult;
11358 }
11359
11360
11361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
11362   void * jresult ;
11363   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11364   float arg2 ;
11365   Dali::Quaternion *result = 0 ;
11366
11367   arg1 = (Dali::Quaternion *)jarg1;
11368   arg2 = (float)jarg2;
11369   {
11370     try {
11371       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
11372     } catch (std::out_of_range& e) {
11373       {
11374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11375       };
11376     } catch (std::exception& e) {
11377       {
11378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11379       };
11380     } catch (Dali::DaliException e) {
11381       {
11382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11383       };
11384     } catch (...) {
11385       {
11386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11387       };
11388     }
11389   }
11390
11391   jresult = (void *)result;
11392   return jresult;
11393 }
11394
11395
11396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
11397   void * jresult ;
11398   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11399   float arg2 ;
11400   Dali::Quaternion *result = 0 ;
11401
11402   arg1 = (Dali::Quaternion *)jarg1;
11403   arg2 = (float)jarg2;
11404   {
11405     try {
11406       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
11407     } catch (std::out_of_range& e) {
11408       {
11409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11410       };
11411     } catch (std::exception& e) {
11412       {
11413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11414       };
11415     } catch (Dali::DaliException e) {
11416       {
11417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11418       };
11419     } catch (...) {
11420       {
11421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11422       };
11423     }
11424   }
11425
11426   jresult = (void *)result;
11427   return jresult;
11428 }
11429
11430
11431 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
11432   unsigned int jresult ;
11433   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11434   Dali::Quaternion *arg2 = 0 ;
11435   bool result;
11436
11437   arg1 = (Dali::Quaternion *)jarg1;
11438   arg2 = (Dali::Quaternion *)jarg2;
11439   if (!arg2) {
11440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11441     return 0;
11442   }
11443   {
11444     try {
11445       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
11446     } catch (std::out_of_range& e) {
11447       {
11448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11449       };
11450     } catch (std::exception& e) {
11451       {
11452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11453       };
11454     } catch (Dali::DaliException e) {
11455       {
11456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11457       };
11458     } catch (...) {
11459       {
11460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11461       };
11462     }
11463   }
11464
11465   jresult = result;
11466   return jresult;
11467 }
11468
11469
11470 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
11471   unsigned int jresult ;
11472   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11473   Dali::Quaternion *arg2 = 0 ;
11474   bool result;
11475
11476   arg1 = (Dali::Quaternion *)jarg1;
11477   arg2 = (Dali::Quaternion *)jarg2;
11478   if (!arg2) {
11479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11480     return 0;
11481   }
11482   {
11483     try {
11484       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
11485     } catch (std::out_of_range& e) {
11486       {
11487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11488       };
11489     } catch (std::exception& e) {
11490       {
11491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11492       };
11493     } catch (Dali::DaliException e) {
11494       {
11495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11496       };
11497     } catch (...) {
11498       {
11499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11500       };
11501     }
11502   }
11503
11504   jresult = result;
11505   return jresult;
11506 }
11507
11508
11509 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
11510   float jresult ;
11511   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11512   float result;
11513
11514   arg1 = (Dali::Quaternion *)jarg1;
11515   {
11516     try {
11517       result = (float)((Dali::Quaternion const *)arg1)->Length();
11518     } catch (std::out_of_range& e) {
11519       {
11520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11521       };
11522     } catch (std::exception& e) {
11523       {
11524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11525       };
11526     } catch (Dali::DaliException e) {
11527       {
11528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11529       };
11530     } catch (...) {
11531       {
11532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11533       };
11534     }
11535   }
11536
11537   jresult = result;
11538   return jresult;
11539 }
11540
11541
11542 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
11543   float jresult ;
11544   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11545   float result;
11546
11547   arg1 = (Dali::Quaternion *)jarg1;
11548   {
11549     try {
11550       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
11551     } catch (std::out_of_range& e) {
11552       {
11553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11554       };
11555     } catch (std::exception& e) {
11556       {
11557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11558       };
11559     } catch (Dali::DaliException e) {
11560       {
11561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11562       };
11563     } catch (...) {
11564       {
11565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11566       };
11567     }
11568   }
11569
11570   jresult = result;
11571   return jresult;
11572 }
11573
11574
11575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
11576   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11577
11578   arg1 = (Dali::Quaternion *)jarg1;
11579   {
11580     try {
11581       (arg1)->Normalize();
11582     } catch (std::out_of_range& e) {
11583       {
11584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11585       };
11586     } catch (std::exception& e) {
11587       {
11588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11589       };
11590     } catch (Dali::DaliException e) {
11591       {
11592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11593       };
11594     } catch (...) {
11595       {
11596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11597       };
11598     }
11599   }
11600
11601 }
11602
11603
11604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
11605   void * jresult ;
11606   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11607   Dali::Quaternion result;
11608
11609   arg1 = (Dali::Quaternion *)jarg1;
11610   {
11611     try {
11612       result = ((Dali::Quaternion const *)arg1)->Normalized();
11613     } catch (std::out_of_range& e) {
11614       {
11615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11616       };
11617     } catch (std::exception& e) {
11618       {
11619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11620       };
11621     } catch (Dali::DaliException e) {
11622       {
11623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11624       };
11625     } catch (...) {
11626       {
11627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11628       };
11629     }
11630   }
11631
11632   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11633   return jresult;
11634 }
11635
11636
11637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
11638   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11639
11640   arg1 = (Dali::Quaternion *)jarg1;
11641   {
11642     try {
11643       (arg1)->Conjugate();
11644     } catch (std::out_of_range& e) {
11645       {
11646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11647       };
11648     } catch (std::exception& e) {
11649       {
11650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11651       };
11652     } catch (Dali::DaliException e) {
11653       {
11654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11655       };
11656     } catch (...) {
11657       {
11658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11659       };
11660     }
11661   }
11662
11663 }
11664
11665
11666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
11667   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11668
11669   arg1 = (Dali::Quaternion *)jarg1;
11670   {
11671     try {
11672       (arg1)->Invert();
11673     } catch (std::out_of_range& e) {
11674       {
11675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11676       };
11677     } catch (std::exception& e) {
11678       {
11679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11680       };
11681     } catch (Dali::DaliException e) {
11682       {
11683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11684       };
11685     } catch (...) {
11686       {
11687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11688       };
11689     }
11690   }
11691
11692 }
11693
11694
11695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
11696   void * jresult ;
11697   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11698   Dali::Quaternion result;
11699
11700   arg1 = (Dali::Quaternion *)jarg1;
11701   {
11702     try {
11703       result = ((Dali::Quaternion const *)arg1)->Log();
11704     } catch (std::out_of_range& e) {
11705       {
11706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11707       };
11708     } catch (std::exception& e) {
11709       {
11710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11711       };
11712     } catch (Dali::DaliException e) {
11713       {
11714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11715       };
11716     } catch (...) {
11717       {
11718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11719       };
11720     }
11721   }
11722
11723   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11724   return jresult;
11725 }
11726
11727
11728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
11729   void * jresult ;
11730   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11731   Dali::Quaternion result;
11732
11733   arg1 = (Dali::Quaternion *)jarg1;
11734   {
11735     try {
11736       result = ((Dali::Quaternion const *)arg1)->Exp();
11737     } catch (std::out_of_range& e) {
11738       {
11739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11740       };
11741     } catch (std::exception& e) {
11742       {
11743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11744       };
11745     } catch (Dali::DaliException e) {
11746       {
11747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11748       };
11749     } catch (...) {
11750       {
11751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11752       };
11753     }
11754   }
11755
11756   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11757   return jresult;
11758 }
11759
11760
11761 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
11762   float jresult ;
11763   Dali::Quaternion *arg1 = 0 ;
11764   Dali::Quaternion *arg2 = 0 ;
11765   float result;
11766
11767   arg1 = (Dali::Quaternion *)jarg1;
11768   if (!arg1) {
11769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11770     return 0;
11771   }
11772   arg2 = (Dali::Quaternion *)jarg2;
11773   if (!arg2) {
11774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11775     return 0;
11776   }
11777   {
11778     try {
11779       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
11780     } catch (std::out_of_range& e) {
11781       {
11782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11783       };
11784     } catch (std::exception& e) {
11785       {
11786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11787       };
11788     } catch (Dali::DaliException e) {
11789       {
11790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11791       };
11792     } catch (...) {
11793       {
11794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11795       };
11796     }
11797   }
11798
11799   jresult = result;
11800   return jresult;
11801 }
11802
11803
11804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
11805   void * jresult ;
11806   Dali::Quaternion *arg1 = 0 ;
11807   Dali::Quaternion *arg2 = 0 ;
11808   float arg3 ;
11809   Dali::Quaternion result;
11810
11811   arg1 = (Dali::Quaternion *)jarg1;
11812   if (!arg1) {
11813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11814     return 0;
11815   }
11816   arg2 = (Dali::Quaternion *)jarg2;
11817   if (!arg2) {
11818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11819     return 0;
11820   }
11821   arg3 = (float)jarg3;
11822   {
11823     try {
11824       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11825     } catch (std::out_of_range& e) {
11826       {
11827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11828       };
11829     } catch (std::exception& e) {
11830       {
11831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11832       };
11833     } catch (Dali::DaliException e) {
11834       {
11835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11836       };
11837     } catch (...) {
11838       {
11839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11840       };
11841     }
11842   }
11843
11844   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11845   return jresult;
11846 }
11847
11848
11849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
11850   void * jresult ;
11851   Dali::Quaternion *arg1 = 0 ;
11852   Dali::Quaternion *arg2 = 0 ;
11853   float arg3 ;
11854   Dali::Quaternion result;
11855
11856   arg1 = (Dali::Quaternion *)jarg1;
11857   if (!arg1) {
11858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11859     return 0;
11860   }
11861   arg2 = (Dali::Quaternion *)jarg2;
11862   if (!arg2) {
11863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11864     return 0;
11865   }
11866   arg3 = (float)jarg3;
11867   {
11868     try {
11869       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11870     } catch (std::out_of_range& e) {
11871       {
11872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11873       };
11874     } catch (std::exception& e) {
11875       {
11876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11877       };
11878     } catch (Dali::DaliException e) {
11879       {
11880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11881       };
11882     } catch (...) {
11883       {
11884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11885       };
11886     }
11887   }
11888
11889   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11890   return jresult;
11891 }
11892
11893
11894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
11895   void * jresult ;
11896   Dali::Quaternion *arg1 = 0 ;
11897   Dali::Quaternion *arg2 = 0 ;
11898   float arg3 ;
11899   Dali::Quaternion result;
11900
11901   arg1 = (Dali::Quaternion *)jarg1;
11902   if (!arg1) {
11903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11904     return 0;
11905   }
11906   arg2 = (Dali::Quaternion *)jarg2;
11907   if (!arg2) {
11908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11909     return 0;
11910   }
11911   arg3 = (float)jarg3;
11912   {
11913     try {
11914       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11915     } catch (std::out_of_range& e) {
11916       {
11917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11918       };
11919     } catch (std::exception& e) {
11920       {
11921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11922       };
11923     } catch (Dali::DaliException e) {
11924       {
11925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11926       };
11927     } catch (...) {
11928       {
11929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11930       };
11931     }
11932   }
11933
11934   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11935   return jresult;
11936 }
11937
11938
11939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
11940   void * jresult ;
11941   Dali::Quaternion *arg1 = 0 ;
11942   Dali::Quaternion *arg2 = 0 ;
11943   Dali::Quaternion *arg3 = 0 ;
11944   Dali::Quaternion *arg4 = 0 ;
11945   float arg5 ;
11946   Dali::Quaternion result;
11947
11948   arg1 = (Dali::Quaternion *)jarg1;
11949   if (!arg1) {
11950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11951     return 0;
11952   }
11953   arg2 = (Dali::Quaternion *)jarg2;
11954   if (!arg2) {
11955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11956     return 0;
11957   }
11958   arg3 = (Dali::Quaternion *)jarg3;
11959   if (!arg3) {
11960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11961     return 0;
11962   }
11963   arg4 = (Dali::Quaternion *)jarg4;
11964   if (!arg4) {
11965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11966     return 0;
11967   }
11968   arg5 = (float)jarg5;
11969   {
11970     try {
11971       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
11972     } catch (std::out_of_range& e) {
11973       {
11974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11975       };
11976     } catch (std::exception& e) {
11977       {
11978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11979       };
11980     } catch (Dali::DaliException e) {
11981       {
11982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11983       };
11984     } catch (...) {
11985       {
11986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11987       };
11988     }
11989   }
11990
11991   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11992   return jresult;
11993 }
11994
11995
11996 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
11997   float jresult ;
11998   Dali::Quaternion *arg1 = 0 ;
11999   Dali::Quaternion *arg2 = 0 ;
12000   float result;
12001
12002   arg1 = (Dali::Quaternion *)jarg1;
12003   if (!arg1) {
12004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12005     return 0;
12006   }
12007   arg2 = (Dali::Quaternion *)jarg2;
12008   if (!arg2) {
12009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12010     return 0;
12011   }
12012   {
12013     try {
12014       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
12015     } catch (std::out_of_range& e) {
12016       {
12017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12018       };
12019     } catch (std::exception& e) {
12020       {
12021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12022       };
12023     } catch (Dali::DaliException e) {
12024       {
12025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12026       };
12027     } catch (...) {
12028       {
12029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12030       };
12031     }
12032   }
12033
12034   jresult = result;
12035   return jresult;
12036 }
12037
12038
12039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
12040   void * jresult ;
12041   Dali::Matrix *result = 0 ;
12042
12043   {
12044     try {
12045       result = (Dali::Matrix *)new Dali::Matrix();
12046     } catch (std::out_of_range& e) {
12047       {
12048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12049       };
12050     } catch (std::exception& e) {
12051       {
12052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12053       };
12054     } catch (Dali::DaliException e) {
12055       {
12056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12057       };
12058     } catch (...) {
12059       {
12060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12061       };
12062     }
12063   }
12064
12065   jresult = (void *)result;
12066   return jresult;
12067 }
12068
12069
12070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
12071   void * jresult ;
12072   bool arg1 ;
12073   Dali::Matrix *result = 0 ;
12074
12075   arg1 = jarg1 ? true : false;
12076   {
12077     try {
12078       result = (Dali::Matrix *)new Dali::Matrix(arg1);
12079     } catch (std::out_of_range& e) {
12080       {
12081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12082       };
12083     } catch (std::exception& e) {
12084       {
12085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12086       };
12087     } catch (Dali::DaliException e) {
12088       {
12089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12090       };
12091     } catch (...) {
12092       {
12093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12094       };
12095     }
12096   }
12097
12098   jresult = (void *)result;
12099   return jresult;
12100 }
12101
12102
12103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
12104   void * jresult ;
12105   float *arg1 = (float *) 0 ;
12106   Dali::Matrix *result = 0 ;
12107
12108   arg1 = jarg1;
12109   {
12110     try {
12111       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
12112     } catch (std::out_of_range& e) {
12113       {
12114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12115       };
12116     } catch (std::exception& e) {
12117       {
12118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12119       };
12120     } catch (Dali::DaliException e) {
12121       {
12122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12123       };
12124     } catch (...) {
12125       {
12126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12127       };
12128     }
12129   }
12130
12131   jresult = (void *)result;
12132
12133
12134   return jresult;
12135 }
12136
12137
12138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
12139   void * jresult ;
12140   Dali::Quaternion *arg1 = 0 ;
12141   Dali::Matrix *result = 0 ;
12142
12143   arg1 = (Dali::Quaternion *)jarg1;
12144   if (!arg1) {
12145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12146     return 0;
12147   }
12148   {
12149     try {
12150       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
12151     } catch (std::out_of_range& e) {
12152       {
12153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12154       };
12155     } catch (std::exception& e) {
12156       {
12157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12158       };
12159     } catch (Dali::DaliException e) {
12160       {
12161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12162       };
12163     } catch (...) {
12164       {
12165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12166       };
12167     }
12168   }
12169
12170   jresult = (void *)result;
12171   return jresult;
12172 }
12173
12174
12175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
12176   void * jresult ;
12177   Dali::Matrix *arg1 = 0 ;
12178   Dali::Matrix *result = 0 ;
12179
12180   arg1 = (Dali::Matrix *)jarg1;
12181   if (!arg1) {
12182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12183     return 0;
12184   }
12185   {
12186     try {
12187       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
12188     } catch (std::out_of_range& e) {
12189       {
12190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12191       };
12192     } catch (std::exception& e) {
12193       {
12194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12195       };
12196     } catch (Dali::DaliException e) {
12197       {
12198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12199       };
12200     } catch (...) {
12201       {
12202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12203       };
12204     }
12205   }
12206
12207   jresult = (void *)result;
12208   return jresult;
12209 }
12210
12211
12212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
12213   void * jresult ;
12214   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12215   Dali::Matrix *arg2 = 0 ;
12216   Dali::Matrix *result = 0 ;
12217
12218   arg1 = (Dali::Matrix *)jarg1;
12219   arg2 = (Dali::Matrix *)jarg2;
12220   if (!arg2) {
12221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12222     return 0;
12223   }
12224   {
12225     try {
12226       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12227     } catch (std::out_of_range& e) {
12228       {
12229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12230       };
12231     } catch (std::exception& e) {
12232       {
12233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12234       };
12235     } catch (Dali::DaliException e) {
12236       {
12237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12238       };
12239     } catch (...) {
12240       {
12241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12242       };
12243     }
12244   }
12245
12246   jresult = (void *)result;
12247   return jresult;
12248 }
12249
12250
12251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
12252   void * jresult ;
12253   Dali::Matrix *result = 0 ;
12254
12255   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
12256   jresult = (void *)result;
12257   return jresult;
12258 }
12259
12260
12261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
12262   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12263
12264   arg1 = (Dali::Matrix *)jarg1;
12265   {
12266     try {
12267       (arg1)->SetIdentity();
12268     } catch (std::out_of_range& e) {
12269       {
12270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12271       };
12272     } catch (std::exception& e) {
12273       {
12274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12275       };
12276     } catch (Dali::DaliException e) {
12277       {
12278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12279       };
12280     } catch (...) {
12281       {
12282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12283       };
12284     }
12285   }
12286
12287 }
12288
12289
12290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
12291   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12292   Dali::Vector3 *arg2 = 0 ;
12293
12294   arg1 = (Dali::Matrix *)jarg1;
12295   arg2 = (Dali::Vector3 *)jarg2;
12296   if (!arg2) {
12297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12298     return ;
12299   }
12300   {
12301     try {
12302       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
12303     } catch (std::out_of_range& e) {
12304       {
12305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12306       };
12307     } catch (std::exception& e) {
12308       {
12309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12310       };
12311     } catch (Dali::DaliException e) {
12312       {
12313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12314       };
12315     } catch (...) {
12316       {
12317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12318       };
12319     }
12320   }
12321
12322 }
12323
12324
12325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
12326   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12327   Dali::Matrix *arg2 = 0 ;
12328
12329   arg1 = (Dali::Matrix *)jarg1;
12330   arg2 = (Dali::Matrix *)jarg2;
12331   if (!arg2) {
12332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12333     return ;
12334   }
12335   {
12336     try {
12337       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
12338     } catch (std::out_of_range& e) {
12339       {
12340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12341       };
12342     } catch (std::exception& e) {
12343       {
12344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12345       };
12346     } catch (Dali::DaliException e) {
12347       {
12348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12349       };
12350     } catch (...) {
12351       {
12352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12353       };
12354     }
12355   }
12356
12357 }
12358
12359
12360 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
12361   unsigned int jresult ;
12362   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12363   bool result;
12364
12365   arg1 = (Dali::Matrix *)jarg1;
12366   {
12367     try {
12368       result = (bool)(arg1)->Invert();
12369     } catch (std::out_of_range& e) {
12370       {
12371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12372       };
12373     } catch (std::exception& e) {
12374       {
12375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12376       };
12377     } catch (Dali::DaliException e) {
12378       {
12379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12380       };
12381     } catch (...) {
12382       {
12383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12384       };
12385     }
12386   }
12387
12388   jresult = result;
12389   return jresult;
12390 }
12391
12392
12393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
12394   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12395
12396   arg1 = (Dali::Matrix *)jarg1;
12397   {
12398     try {
12399       (arg1)->Transpose();
12400     } catch (std::out_of_range& e) {
12401       {
12402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12403       };
12404     } catch (std::exception& e) {
12405       {
12406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12407       };
12408     } catch (Dali::DaliException e) {
12409       {
12410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12411       };
12412     } catch (...) {
12413       {
12414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12415       };
12416     }
12417   }
12418
12419 }
12420
12421
12422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
12423   void * jresult ;
12424   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12425   Dali::Vector3 result;
12426
12427   arg1 = (Dali::Matrix *)jarg1;
12428   {
12429     try {
12430       result = ((Dali::Matrix const *)arg1)->GetXAxis();
12431     } catch (std::out_of_range& e) {
12432       {
12433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12434       };
12435     } catch (std::exception& e) {
12436       {
12437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12438       };
12439     } catch (Dali::DaliException e) {
12440       {
12441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12442       };
12443     } catch (...) {
12444       {
12445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12446       };
12447     }
12448   }
12449
12450   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12451   return jresult;
12452 }
12453
12454
12455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
12456   void * jresult ;
12457   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12458   Dali::Vector3 result;
12459
12460   arg1 = (Dali::Matrix *)jarg1;
12461   {
12462     try {
12463       result = ((Dali::Matrix const *)arg1)->GetYAxis();
12464     } catch (std::out_of_range& e) {
12465       {
12466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12467       };
12468     } catch (std::exception& e) {
12469       {
12470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12471       };
12472     } catch (Dali::DaliException e) {
12473       {
12474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12475       };
12476     } catch (...) {
12477       {
12478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12479       };
12480     }
12481   }
12482
12483   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12484   return jresult;
12485 }
12486
12487
12488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
12489   void * jresult ;
12490   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12491   Dali::Vector3 result;
12492
12493   arg1 = (Dali::Matrix *)jarg1;
12494   {
12495     try {
12496       result = ((Dali::Matrix const *)arg1)->GetZAxis();
12497     } catch (std::out_of_range& e) {
12498       {
12499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12500       };
12501     } catch (std::exception& e) {
12502       {
12503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12504       };
12505     } catch (Dali::DaliException e) {
12506       {
12507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12508       };
12509     } catch (...) {
12510       {
12511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12512       };
12513     }
12514   }
12515
12516   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12517   return jresult;
12518 }
12519
12520
12521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
12522   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12523   Dali::Vector3 *arg2 = 0 ;
12524
12525   arg1 = (Dali::Matrix *)jarg1;
12526   arg2 = (Dali::Vector3 *)jarg2;
12527   if (!arg2) {
12528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12529     return ;
12530   }
12531   {
12532     try {
12533       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
12534     } catch (std::out_of_range& e) {
12535       {
12536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12537       };
12538     } catch (std::exception& e) {
12539       {
12540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12541       };
12542     } catch (Dali::DaliException e) {
12543       {
12544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12545       };
12546     } catch (...) {
12547       {
12548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12549       };
12550     }
12551   }
12552
12553 }
12554
12555
12556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
12557   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12558   Dali::Vector3 *arg2 = 0 ;
12559
12560   arg1 = (Dali::Matrix *)jarg1;
12561   arg2 = (Dali::Vector3 *)jarg2;
12562   if (!arg2) {
12563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12564     return ;
12565   }
12566   {
12567     try {
12568       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
12569     } catch (std::out_of_range& e) {
12570       {
12571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12572       };
12573     } catch (std::exception& e) {
12574       {
12575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12576       };
12577     } catch (Dali::DaliException e) {
12578       {
12579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12580       };
12581     } catch (...) {
12582       {
12583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12584       };
12585     }
12586   }
12587
12588 }
12589
12590
12591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
12592   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12593   Dali::Vector3 *arg2 = 0 ;
12594
12595   arg1 = (Dali::Matrix *)jarg1;
12596   arg2 = (Dali::Vector3 *)jarg2;
12597   if (!arg2) {
12598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12599     return ;
12600   }
12601   {
12602     try {
12603       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
12604     } catch (std::out_of_range& e) {
12605       {
12606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12607       };
12608     } catch (std::exception& e) {
12609       {
12610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12611       };
12612     } catch (Dali::DaliException e) {
12613       {
12614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12615       };
12616     } catch (...) {
12617       {
12618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12619       };
12620     }
12621   }
12622
12623 }
12624
12625
12626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
12627   void * jresult ;
12628   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12629   Dali::Vector4 *result = 0 ;
12630
12631   arg1 = (Dali::Matrix *)jarg1;
12632   {
12633     try {
12634       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
12635     } catch (std::out_of_range& e) {
12636       {
12637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12638       };
12639     } catch (std::exception& e) {
12640       {
12641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12642       };
12643     } catch (Dali::DaliException e) {
12644       {
12645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12646       };
12647     } catch (...) {
12648       {
12649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12650       };
12651     }
12652   }
12653
12654   jresult = (void *)result;
12655   return jresult;
12656 }
12657
12658
12659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
12660   void * jresult ;
12661   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12662   Dali::Vector3 *result = 0 ;
12663
12664   arg1 = (Dali::Matrix *)jarg1;
12665   {
12666     try {
12667       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
12668     } catch (std::out_of_range& e) {
12669       {
12670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12671       };
12672     } catch (std::exception& e) {
12673       {
12674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12675       };
12676     } catch (Dali::DaliException e) {
12677       {
12678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12679       };
12680     } catch (...) {
12681       {
12682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12683       };
12684     }
12685   }
12686
12687   jresult = (void *)result;
12688   return jresult;
12689 }
12690
12691
12692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
12693   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12694   Dali::Vector4 *arg2 = 0 ;
12695
12696   arg1 = (Dali::Matrix *)jarg1;
12697   arg2 = (Dali::Vector4 *)jarg2;
12698   if (!arg2) {
12699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
12700     return ;
12701   }
12702   {
12703     try {
12704       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
12705     } catch (std::out_of_range& e) {
12706       {
12707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12708       };
12709     } catch (std::exception& e) {
12710       {
12711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12712       };
12713     } catch (Dali::DaliException e) {
12714       {
12715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12716       };
12717     } catch (...) {
12718       {
12719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12720       };
12721     }
12722   }
12723
12724 }
12725
12726
12727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
12728   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12729   Dali::Vector3 *arg2 = 0 ;
12730
12731   arg1 = (Dali::Matrix *)jarg1;
12732   arg2 = (Dali::Vector3 *)jarg2;
12733   if (!arg2) {
12734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12735     return ;
12736   }
12737   {
12738     try {
12739       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
12740     } catch (std::out_of_range& e) {
12741       {
12742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12743       };
12744     } catch (std::exception& e) {
12745       {
12746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12747       };
12748     } catch (Dali::DaliException e) {
12749       {
12750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12751       };
12752     } catch (...) {
12753       {
12754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12755       };
12756     }
12757   }
12758
12759 }
12760
12761
12762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
12763   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12764
12765   arg1 = (Dali::Matrix *)jarg1;
12766   {
12767     try {
12768       (arg1)->OrthoNormalize();
12769     } catch (std::out_of_range& e) {
12770       {
12771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12772       };
12773     } catch (std::exception& e) {
12774       {
12775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12776       };
12777     } catch (Dali::DaliException e) {
12778       {
12779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12780       };
12781     } catch (...) {
12782       {
12783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12784       };
12785     }
12786   }
12787
12788 }
12789
12790
12791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
12792   void * jresult ;
12793   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12794   float *result = 0 ;
12795
12796   arg1 = (Dali::Matrix *)jarg1;
12797   {
12798     try {
12799       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
12800     } catch (std::out_of_range& e) {
12801       {
12802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12803       };
12804     } catch (std::exception& e) {
12805       {
12806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12807       };
12808     } catch (Dali::DaliException e) {
12809       {
12810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12811       };
12812     } catch (...) {
12813       {
12814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12815       };
12816     }
12817   }
12818
12819   jresult = (void *)result;
12820   return jresult;
12821 }
12822
12823
12824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
12825   Dali::Matrix *arg1 = 0 ;
12826   Dali::Matrix *arg2 = 0 ;
12827   Dali::Matrix *arg3 = 0 ;
12828
12829   arg1 = (Dali::Matrix *)jarg1;
12830   if (!arg1) {
12831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12832     return ;
12833   }
12834   arg2 = (Dali::Matrix *)jarg2;
12835   if (!arg2) {
12836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12837     return ;
12838   }
12839   arg3 = (Dali::Matrix *)jarg3;
12840   if (!arg3) {
12841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12842     return ;
12843   }
12844   {
12845     try {
12846       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
12847     } catch (std::out_of_range& e) {
12848       {
12849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12850       };
12851     } catch (std::exception& e) {
12852       {
12853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12854       };
12855     } catch (Dali::DaliException e) {
12856       {
12857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12858       };
12859     } catch (...) {
12860       {
12861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12862       };
12863     }
12864   }
12865
12866 }
12867
12868
12869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
12870   Dali::Matrix *arg1 = 0 ;
12871   Dali::Matrix *arg2 = 0 ;
12872   Dali::Quaternion *arg3 = 0 ;
12873
12874   arg1 = (Dali::Matrix *)jarg1;
12875   if (!arg1) {
12876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12877     return ;
12878   }
12879   arg2 = (Dali::Matrix *)jarg2;
12880   if (!arg2) {
12881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12882     return ;
12883   }
12884   arg3 = (Dali::Quaternion *)jarg3;
12885   if (!arg3) {
12886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12887     return ;
12888   }
12889   {
12890     try {
12891       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
12892     } catch (std::out_of_range& e) {
12893       {
12894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12895       };
12896     } catch (std::exception& e) {
12897       {
12898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12899       };
12900     } catch (Dali::DaliException e) {
12901       {
12902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12903       };
12904     } catch (...) {
12905       {
12906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12907       };
12908     }
12909   }
12910
12911 }
12912
12913
12914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
12915   void * jresult ;
12916   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12917   Dali::Vector4 *arg2 = 0 ;
12918   Dali::Vector4 result;
12919
12920   arg1 = (Dali::Matrix *)jarg1;
12921   arg2 = (Dali::Vector4 *)jarg2;
12922   if (!arg2) {
12923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
12924     return 0;
12925   }
12926   {
12927     try {
12928       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
12929     } catch (std::out_of_range& e) {
12930       {
12931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12932       };
12933     } catch (std::exception& e) {
12934       {
12935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12936       };
12937     } catch (Dali::DaliException e) {
12938       {
12939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12940       };
12941     } catch (...) {
12942       {
12943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12944       };
12945     }
12946   }
12947
12948   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
12949   return jresult;
12950 }
12951
12952
12953 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
12954   unsigned int jresult ;
12955   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12956   Dali::Matrix *arg2 = 0 ;
12957   bool result;
12958
12959   arg1 = (Dali::Matrix *)jarg1;
12960   arg2 = (Dali::Matrix *)jarg2;
12961   if (!arg2) {
12962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12963     return 0;
12964   }
12965   {
12966     try {
12967       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
12968     } catch (std::out_of_range& e) {
12969       {
12970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12971       };
12972     } catch (std::exception& e) {
12973       {
12974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12975       };
12976     } catch (Dali::DaliException e) {
12977       {
12978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12979       };
12980     } catch (...) {
12981       {
12982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12983       };
12984     }
12985   }
12986
12987   jresult = result;
12988   return jresult;
12989 }
12990
12991
12992 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
12993   unsigned int jresult ;
12994   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12995   Dali::Matrix *arg2 = 0 ;
12996   bool result;
12997
12998   arg1 = (Dali::Matrix *)jarg1;
12999   arg2 = (Dali::Matrix *)jarg2;
13000   if (!arg2) {
13001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13002     return 0;
13003   }
13004   {
13005     try {
13006       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
13007     } catch (std::out_of_range& e) {
13008       {
13009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13010       };
13011     } catch (std::exception& e) {
13012       {
13013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13014       };
13015     } catch (Dali::DaliException e) {
13016       {
13017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13018       };
13019     } catch (...) {
13020       {
13021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13022       };
13023     }
13024   }
13025
13026   jresult = result;
13027   return jresult;
13028 }
13029
13030
13031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13032   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13033   Dali::Vector3 *arg2 = 0 ;
13034   Dali::Quaternion *arg3 = 0 ;
13035   Dali::Vector3 *arg4 = 0 ;
13036
13037   arg1 = (Dali::Matrix *)jarg1;
13038   arg2 = (Dali::Vector3 *)jarg2;
13039   if (!arg2) {
13040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13041     return ;
13042   }
13043   arg3 = (Dali::Quaternion *)jarg3;
13044   if (!arg3) {
13045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13046     return ;
13047   }
13048   arg4 = (Dali::Vector3 *)jarg4;
13049   if (!arg4) {
13050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13051     return ;
13052   }
13053   {
13054     try {
13055       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13056     } catch (std::out_of_range& e) {
13057       {
13058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13059       };
13060     } catch (std::exception& e) {
13061       {
13062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13063       };
13064     } catch (Dali::DaliException e) {
13065       {
13066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13067       };
13068     } catch (...) {
13069       {
13070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13071       };
13072     }
13073   }
13074
13075 }
13076
13077
13078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13079   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13080   Dali::Vector3 *arg2 = 0 ;
13081   Dali::Quaternion *arg3 = 0 ;
13082   Dali::Vector3 *arg4 = 0 ;
13083
13084   arg1 = (Dali::Matrix *)jarg1;
13085   arg2 = (Dali::Vector3 *)jarg2;
13086   if (!arg2) {
13087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13088     return ;
13089   }
13090   arg3 = (Dali::Quaternion *)jarg3;
13091   if (!arg3) {
13092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13093     return ;
13094   }
13095   arg4 = (Dali::Vector3 *)jarg4;
13096   if (!arg4) {
13097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13098     return ;
13099   }
13100   {
13101     try {
13102       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13103     } catch (std::out_of_range& e) {
13104       {
13105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13106       };
13107     } catch (std::exception& e) {
13108       {
13109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13110       };
13111     } catch (Dali::DaliException e) {
13112       {
13113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13114       };
13115     } catch (...) {
13116       {
13117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13118       };
13119     }
13120   }
13121
13122 }
13123
13124
13125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
13126   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13127   Dali::Vector3 *arg2 = 0 ;
13128   Dali::Vector3 *arg3 = 0 ;
13129   Dali::Vector3 *arg4 = 0 ;
13130   Dali::Vector3 *arg5 = 0 ;
13131
13132   arg1 = (Dali::Matrix *)jarg1;
13133   arg2 = (Dali::Vector3 *)jarg2;
13134   if (!arg2) {
13135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13136     return ;
13137   }
13138   arg3 = (Dali::Vector3 *)jarg3;
13139   if (!arg3) {
13140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13141     return ;
13142   }
13143   arg4 = (Dali::Vector3 *)jarg4;
13144   if (!arg4) {
13145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13146     return ;
13147   }
13148   arg5 = (Dali::Vector3 *)jarg5;
13149   if (!arg5) {
13150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13151     return ;
13152   }
13153   {
13154     try {
13155       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
13156     } catch (std::out_of_range& e) {
13157       {
13158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13159       };
13160     } catch (std::exception& e) {
13161       {
13162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13163       };
13164     } catch (Dali::DaliException e) {
13165       {
13166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13167       };
13168     } catch (...) {
13169       {
13170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13171       };
13172     }
13173   }
13174
13175 }
13176
13177
13178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13179   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13180   Dali::Vector3 *arg2 = 0 ;
13181   Dali::Quaternion *arg3 = 0 ;
13182   Dali::Vector3 *arg4 = 0 ;
13183
13184   arg1 = (Dali::Matrix *)jarg1;
13185   arg2 = (Dali::Vector3 *)jarg2;
13186   if (!arg2) {
13187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13188     return ;
13189   }
13190   arg3 = (Dali::Quaternion *)jarg3;
13191   if (!arg3) {
13192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
13193     return ;
13194   }
13195   arg4 = (Dali::Vector3 *)jarg4;
13196   if (!arg4) {
13197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13198     return ;
13199   }
13200   {
13201     try {
13202       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
13203     } catch (std::out_of_range& e) {
13204       {
13205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13206       };
13207     } catch (std::exception& e) {
13208       {
13209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13210       };
13211     } catch (Dali::DaliException e) {
13212       {
13213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13214       };
13215     } catch (...) {
13216       {
13217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13218       };
13219     }
13220   }
13221
13222 }
13223
13224
13225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
13226   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13227
13228   arg1 = (Dali::Matrix *)jarg1;
13229   {
13230     try {
13231       delete arg1;
13232     } catch (std::out_of_range& e) {
13233       {
13234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13235       };
13236     } catch (std::exception& e) {
13237       {
13238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13239       };
13240     } catch (Dali::DaliException e) {
13241       {
13242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13243       };
13244     } catch (...) {
13245       {
13246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13247       };
13248     }
13249   }
13250
13251 }
13252
13253
13254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
13255   void * jresult ;
13256   Dali::Matrix3 *result = 0 ;
13257
13258   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
13259   jresult = (void *)result;
13260   return jresult;
13261 }
13262
13263
13264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
13265   void * jresult ;
13266   Dali::Matrix3 *result = 0 ;
13267
13268   {
13269     try {
13270       result = (Dali::Matrix3 *)new Dali::Matrix3();
13271     } catch (std::out_of_range& e) {
13272       {
13273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13274       };
13275     } catch (std::exception& e) {
13276       {
13277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13278       };
13279     } catch (Dali::DaliException e) {
13280       {
13281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13282       };
13283     } catch (...) {
13284       {
13285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13286       };
13287     }
13288   }
13289
13290   jresult = (void *)result;
13291   return jresult;
13292 }
13293
13294
13295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
13296   void * jresult ;
13297   Dali::Matrix3 *arg1 = 0 ;
13298   Dali::Matrix3 *result = 0 ;
13299
13300   arg1 = (Dali::Matrix3 *)jarg1;
13301   if (!arg1) {
13302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13303     return 0;
13304   }
13305   {
13306     try {
13307       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
13308     } catch (std::out_of_range& e) {
13309       {
13310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13311       };
13312     } catch (std::exception& e) {
13313       {
13314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13315       };
13316     } catch (Dali::DaliException e) {
13317       {
13318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13319       };
13320     } catch (...) {
13321       {
13322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13323       };
13324     }
13325   }
13326
13327   jresult = (void *)result;
13328   return jresult;
13329 }
13330
13331
13332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
13333   void * jresult ;
13334   Dali::Matrix *arg1 = 0 ;
13335   Dali::Matrix3 *result = 0 ;
13336
13337   arg1 = (Dali::Matrix *)jarg1;
13338   if (!arg1) {
13339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13340     return 0;
13341   }
13342   {
13343     try {
13344       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
13345     } catch (std::out_of_range& e) {
13346       {
13347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13348       };
13349     } catch (std::exception& e) {
13350       {
13351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13352       };
13353     } catch (Dali::DaliException e) {
13354       {
13355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13356       };
13357     } catch (...) {
13358       {
13359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13360       };
13361     }
13362   }
13363
13364   jresult = (void *)result;
13365   return jresult;
13366 }
13367
13368
13369 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) {
13370   void * jresult ;
13371   float arg1 ;
13372   float arg2 ;
13373   float arg3 ;
13374   float arg4 ;
13375   float arg5 ;
13376   float arg6 ;
13377   float arg7 ;
13378   float arg8 ;
13379   float arg9 ;
13380   Dali::Matrix3 *result = 0 ;
13381
13382   arg1 = (float)jarg1;
13383   arg2 = (float)jarg2;
13384   arg3 = (float)jarg3;
13385   arg4 = (float)jarg4;
13386   arg5 = (float)jarg5;
13387   arg6 = (float)jarg6;
13388   arg7 = (float)jarg7;
13389   arg8 = (float)jarg8;
13390   arg9 = (float)jarg9;
13391   {
13392     try {
13393       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
13394     } catch (std::out_of_range& e) {
13395       {
13396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13397       };
13398     } catch (std::exception& e) {
13399       {
13400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13401       };
13402     } catch (Dali::DaliException e) {
13403       {
13404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13405       };
13406     } catch (...) {
13407       {
13408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13409       };
13410     }
13411   }
13412
13413   jresult = (void *)result;
13414   return jresult;
13415 }
13416
13417
13418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
13419   void * jresult ;
13420   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13421   Dali::Matrix3 *arg2 = 0 ;
13422   Dali::Matrix3 *result = 0 ;
13423
13424   arg1 = (Dali::Matrix3 *)jarg1;
13425   arg2 = (Dali::Matrix3 *)jarg2;
13426   if (!arg2) {
13427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13428     return 0;
13429   }
13430   {
13431     try {
13432       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
13433     } catch (std::out_of_range& e) {
13434       {
13435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13436       };
13437     } catch (std::exception& e) {
13438       {
13439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13440       };
13441     } catch (Dali::DaliException e) {
13442       {
13443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13444       };
13445     } catch (...) {
13446       {
13447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13448       };
13449     }
13450   }
13451
13452   jresult = (void *)result;
13453   return jresult;
13454 }
13455
13456
13457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
13458   void * jresult ;
13459   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13460   Dali::Matrix *arg2 = 0 ;
13461   Dali::Matrix3 *result = 0 ;
13462
13463   arg1 = (Dali::Matrix3 *)jarg1;
13464   arg2 = (Dali::Matrix *)jarg2;
13465   if (!arg2) {
13466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13467     return 0;
13468   }
13469   {
13470     try {
13471       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
13472     } catch (std::out_of_range& e) {
13473       {
13474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13475       };
13476     } catch (std::exception& e) {
13477       {
13478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13479       };
13480     } catch (Dali::DaliException e) {
13481       {
13482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13483       };
13484     } catch (...) {
13485       {
13486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13487       };
13488     }
13489   }
13490
13491   jresult = (void *)result;
13492   return jresult;
13493 }
13494
13495
13496 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
13497   unsigned int jresult ;
13498   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13499   Dali::Matrix3 *arg2 = 0 ;
13500   bool result;
13501
13502   arg1 = (Dali::Matrix3 *)jarg1;
13503   arg2 = (Dali::Matrix3 *)jarg2;
13504   if (!arg2) {
13505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13506     return 0;
13507   }
13508   {
13509     try {
13510       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
13511     } catch (std::out_of_range& e) {
13512       {
13513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13514       };
13515     } catch (std::exception& e) {
13516       {
13517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13518       };
13519     } catch (Dali::DaliException e) {
13520       {
13521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13522       };
13523     } catch (...) {
13524       {
13525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13526       };
13527     }
13528   }
13529
13530   jresult = result;
13531   return jresult;
13532 }
13533
13534
13535 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
13536   unsigned int jresult ;
13537   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13538   Dali::Matrix3 *arg2 = 0 ;
13539   bool result;
13540
13541   arg1 = (Dali::Matrix3 *)jarg1;
13542   arg2 = (Dali::Matrix3 *)jarg2;
13543   if (!arg2) {
13544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13545     return 0;
13546   }
13547   {
13548     try {
13549       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
13550     } catch (std::out_of_range& e) {
13551       {
13552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13553       };
13554     } catch (std::exception& e) {
13555       {
13556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13557       };
13558     } catch (Dali::DaliException e) {
13559       {
13560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13561       };
13562     } catch (...) {
13563       {
13564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13565       };
13566     }
13567   }
13568
13569   jresult = result;
13570   return jresult;
13571 }
13572
13573
13574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
13575   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13576
13577   arg1 = (Dali::Matrix3 *)jarg1;
13578   {
13579     try {
13580       delete arg1;
13581     } catch (std::out_of_range& e) {
13582       {
13583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13584       };
13585     } catch (std::exception& e) {
13586       {
13587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13588       };
13589     } catch (Dali::DaliException e) {
13590       {
13591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13592       };
13593     } catch (...) {
13594       {
13595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13596       };
13597     }
13598   }
13599
13600 }
13601
13602
13603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
13604   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13605
13606   arg1 = (Dali::Matrix3 *)jarg1;
13607   {
13608     try {
13609       (arg1)->SetIdentity();
13610     } catch (std::out_of_range& e) {
13611       {
13612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13613       };
13614     } catch (std::exception& e) {
13615       {
13616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13617       };
13618     } catch (Dali::DaliException e) {
13619       {
13620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13621       };
13622     } catch (...) {
13623       {
13624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13625       };
13626     }
13627   }
13628
13629 }
13630
13631
13632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
13633   void * jresult ;
13634   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13635   float *result = 0 ;
13636
13637   arg1 = (Dali::Matrix3 *)jarg1;
13638   {
13639     try {
13640       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
13641     } catch (std::out_of_range& e) {
13642       {
13643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13644       };
13645     } catch (std::exception& e) {
13646       {
13647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13648       };
13649     } catch (Dali::DaliException e) {
13650       {
13651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13652       };
13653     } catch (...) {
13654       {
13655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13656       };
13657     }
13658   }
13659
13660   jresult = (void *)result;
13661   return jresult;
13662 }
13663
13664
13665 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
13666   unsigned int jresult ;
13667   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13668   bool result;
13669
13670   arg1 = (Dali::Matrix3 *)jarg1;
13671   {
13672     try {
13673       result = (bool)(arg1)->Invert();
13674     } catch (std::out_of_range& e) {
13675       {
13676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13677       };
13678     } catch (std::exception& e) {
13679       {
13680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13681       };
13682     } catch (Dali::DaliException e) {
13683       {
13684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13685       };
13686     } catch (...) {
13687       {
13688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13689       };
13690     }
13691   }
13692
13693   jresult = result;
13694   return jresult;
13695 }
13696
13697
13698 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
13699   unsigned int jresult ;
13700   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13701   bool result;
13702
13703   arg1 = (Dali::Matrix3 *)jarg1;
13704   {
13705     try {
13706       result = (bool)(arg1)->Transpose();
13707     } catch (std::out_of_range& e) {
13708       {
13709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13710       };
13711     } catch (std::exception& e) {
13712       {
13713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13714       };
13715     } catch (Dali::DaliException e) {
13716       {
13717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13718       };
13719     } catch (...) {
13720       {
13721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13722       };
13723     }
13724   }
13725
13726   jresult = result;
13727   return jresult;
13728 }
13729
13730
13731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
13732   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13733   float arg2 ;
13734
13735   arg1 = (Dali::Matrix3 *)jarg1;
13736   arg2 = (float)jarg2;
13737   {
13738     try {
13739       (arg1)->Scale(arg2);
13740     } catch (std::out_of_range& e) {
13741       {
13742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13743       };
13744     } catch (std::exception& e) {
13745       {
13746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13747       };
13748     } catch (Dali::DaliException e) {
13749       {
13750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13751       };
13752     } catch (...) {
13753       {
13754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13755       };
13756     }
13757   }
13758
13759 }
13760
13761
13762 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
13763   float jresult ;
13764   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13765   float result;
13766
13767   arg1 = (Dali::Matrix3 *)jarg1;
13768   {
13769     try {
13770       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
13771     } catch (std::out_of_range& e) {
13772       {
13773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13774       };
13775     } catch (std::exception& e) {
13776       {
13777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13778       };
13779     } catch (Dali::DaliException e) {
13780       {
13781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13782       };
13783     } catch (...) {
13784       {
13785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13786       };
13787     }
13788   }
13789
13790   jresult = result;
13791   return jresult;
13792 }
13793
13794
13795 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
13796   unsigned int jresult ;
13797   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13798   bool result;
13799
13800   arg1 = (Dali::Matrix3 *)jarg1;
13801   {
13802     try {
13803       result = (bool)(arg1)->ScaledInverseTranspose();
13804     } catch (std::out_of_range& e) {
13805       {
13806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13807       };
13808     } catch (std::exception& e) {
13809       {
13810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13811       };
13812     } catch (Dali::DaliException e) {
13813       {
13814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13815       };
13816     } catch (...) {
13817       {
13818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13819       };
13820     }
13821   }
13822
13823   jresult = result;
13824   return jresult;
13825 }
13826
13827
13828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
13829   Dali::Matrix3 *arg1 = 0 ;
13830   Dali::Matrix3 *arg2 = 0 ;
13831   Dali::Matrix3 *arg3 = 0 ;
13832
13833   arg1 = (Dali::Matrix3 *)jarg1;
13834   if (!arg1) {
13835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
13836     return ;
13837   }
13838   arg2 = (Dali::Matrix3 *)jarg2;
13839   if (!arg2) {
13840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13841     return ;
13842   }
13843   arg3 = (Dali::Matrix3 *)jarg3;
13844   if (!arg3) {
13845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13846     return ;
13847   }
13848   {
13849     try {
13850       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
13851     } catch (std::out_of_range& e) {
13852       {
13853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13854       };
13855     } catch (std::exception& e) {
13856       {
13857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13858       };
13859     } catch (Dali::DaliException e) {
13860       {
13861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13862       };
13863     } catch (...) {
13864       {
13865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13866       };
13867     }
13868   }
13869
13870 }
13871
13872
13873 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
13874   float jresult ;
13875   float arg1 ;
13876   float arg2 ;
13877   float result;
13878
13879   arg1 = (float)jarg1;
13880   arg2 = (float)jarg2;
13881   {
13882     try {
13883       result = (float)Dali::Random::Range(arg1,arg2);
13884     } catch (std::out_of_range& e) {
13885       {
13886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13887       };
13888     } catch (std::exception& e) {
13889       {
13890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13891       };
13892     } catch (Dali::DaliException e) {
13893       {
13894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13895       };
13896     } catch (...) {
13897       {
13898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13899       };
13900     }
13901   }
13902
13903   jresult = result;
13904   return jresult;
13905 }
13906
13907
13908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
13909   void * jresult ;
13910   Dali::Vector4 result;
13911
13912   {
13913     try {
13914       result = Dali::Random::Axis();
13915     } catch (std::out_of_range& e) {
13916       {
13917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13918       };
13919     } catch (std::exception& e) {
13920       {
13921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13922       };
13923     } catch (Dali::DaliException e) {
13924       {
13925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13926       };
13927     } catch (...) {
13928       {
13929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13930       };
13931     }
13932   }
13933
13934   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
13935   return jresult;
13936 }
13937
13938
13939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
13940   void * jresult ;
13941   Dali::AngleAxis *result = 0 ;
13942
13943   {
13944     try {
13945       result = (Dali::AngleAxis *)new Dali::AngleAxis();
13946     } catch (std::out_of_range& e) {
13947       {
13948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13949       };
13950     } catch (std::exception& e) {
13951       {
13952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13953       };
13954     } catch (Dali::DaliException e) {
13955       {
13956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13957       };
13958     } catch (...) {
13959       {
13960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13961       };
13962     }
13963   }
13964
13965   jresult = (void *)result;
13966   return jresult;
13967 }
13968
13969
13970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
13971   void * jresult ;
13972   Dali::Radian arg1 ;
13973   Dali::Vector3 *arg2 = 0 ;
13974   Dali::Radian *argp1 ;
13975   Dali::AngleAxis *result = 0 ;
13976
13977   argp1 = (Dali::Radian *)jarg1;
13978   if (!argp1) {
13979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
13980     return 0;
13981   }
13982   arg1 = *argp1;
13983   arg2 = (Dali::Vector3 *)jarg2;
13984   if (!arg2) {
13985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13986     return 0;
13987   }
13988   {
13989     try {
13990       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
13991     } catch (std::out_of_range& e) {
13992       {
13993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13994       };
13995     } catch (std::exception& e) {
13996       {
13997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13998       };
13999     } catch (Dali::DaliException e) {
14000       {
14001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14002       };
14003     } catch (...) {
14004       {
14005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14006       };
14007     }
14008   }
14009
14010   jresult = (void *)result;
14011   return jresult;
14012 }
14013
14014
14015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
14016   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14017   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
14018
14019   arg1 = (Dali::AngleAxis *)jarg1;
14020   arg2 = (Dali::Radian *)jarg2;
14021   if (arg1) (arg1)->angle = *arg2;
14022 }
14023
14024
14025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
14026   void * jresult ;
14027   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14028   Dali::Radian *result = 0 ;
14029
14030   arg1 = (Dali::AngleAxis *)jarg1;
14031   result = (Dali::Radian *)& ((arg1)->angle);
14032   jresult = (void *)result;
14033   return jresult;
14034 }
14035
14036
14037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
14038   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14039   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
14040
14041   arg1 = (Dali::AngleAxis *)jarg1;
14042   arg2 = (Dali::Vector3 *)jarg2;
14043   if (arg1) (arg1)->axis = *arg2;
14044 }
14045
14046
14047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
14048   void * jresult ;
14049   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14050   Dali::Vector3 *result = 0 ;
14051
14052   arg1 = (Dali::AngleAxis *)jarg1;
14053   result = (Dali::Vector3 *)& ((arg1)->axis);
14054   jresult = (void *)result;
14055   return jresult;
14056 }
14057
14058
14059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
14060   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14061
14062   arg1 = (Dali::AngleAxis *)jarg1;
14063   {
14064     try {
14065       delete arg1;
14066     } catch (std::out_of_range& e) {
14067       {
14068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14069       };
14070     } catch (std::exception& e) {
14071       {
14072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14073       };
14074     } catch (Dali::DaliException e) {
14075       {
14076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14077       };
14078     } catch (...) {
14079       {
14080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14081       };
14082     }
14083   }
14084
14085 }
14086
14087
14088 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
14089   unsigned int jresult ;
14090   Dali::AngleAxis *arg1 = 0 ;
14091   Dali::AngleAxis *arg2 = 0 ;
14092   bool result;
14093
14094   arg1 = (Dali::AngleAxis *)jarg1;
14095   if (!arg1) {
14096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14097     return 0;
14098   }
14099   arg2 = (Dali::AngleAxis *)jarg2;
14100   if (!arg2) {
14101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14102     return 0;
14103   }
14104   {
14105     try {
14106       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
14107     } catch (std::out_of_range& e) {
14108       {
14109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14110       };
14111     } catch (std::exception& e) {
14112       {
14113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14114       };
14115     } catch (Dali::DaliException e) {
14116       {
14117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14118       };
14119     } catch (...) {
14120       {
14121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14122       };
14123     }
14124   }
14125
14126   jresult = result;
14127   return jresult;
14128 }
14129
14130
14131 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
14132   unsigned int jresult ;
14133   unsigned int arg1 ;
14134   unsigned int result;
14135
14136   arg1 = (unsigned int)jarg1;
14137   {
14138     try {
14139       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
14140     } catch (std::out_of_range& e) {
14141       {
14142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14143       };
14144     } catch (std::exception& e) {
14145       {
14146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14147       };
14148     } catch (Dali::DaliException e) {
14149       {
14150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14151       };
14152     } catch (...) {
14153       {
14154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14155       };
14156     }
14157   }
14158
14159   jresult = result;
14160   return jresult;
14161 }
14162
14163
14164 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
14165   unsigned int jresult ;
14166   unsigned int arg1 ;
14167   bool result;
14168
14169   arg1 = (unsigned int)jarg1;
14170   {
14171     try {
14172       result = (bool)Dali::IsPowerOfTwo(arg1);
14173     } catch (std::out_of_range& e) {
14174       {
14175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14176       };
14177     } catch (std::exception& e) {
14178       {
14179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14180       };
14181     } catch (Dali::DaliException e) {
14182       {
14183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14184       };
14185     } catch (...) {
14186       {
14187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14188       };
14189     }
14190   }
14191
14192   jresult = result;
14193   return jresult;
14194 }
14195
14196
14197 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
14198   float jresult ;
14199   float arg1 ;
14200   float arg2 ;
14201   float result;
14202
14203   arg1 = (float)jarg1;
14204   arg2 = (float)jarg2;
14205   {
14206     try {
14207       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
14208     } catch (std::out_of_range& e) {
14209       {
14210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14211       };
14212     } catch (std::exception& e) {
14213       {
14214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14215       };
14216     } catch (Dali::DaliException e) {
14217       {
14218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14219       };
14220     } catch (...) {
14221       {
14222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14223       };
14224     }
14225   }
14226
14227   jresult = result;
14228   return jresult;
14229 }
14230
14231
14232 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
14233   unsigned int jresult ;
14234   float arg1 ;
14235   bool result;
14236
14237   arg1 = (float)jarg1;
14238   {
14239     try {
14240       result = (bool)Dali::EqualsZero(arg1);
14241     } catch (std::out_of_range& e) {
14242       {
14243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14244       };
14245     } catch (std::exception& e) {
14246       {
14247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14248       };
14249     } catch (Dali::DaliException e) {
14250       {
14251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14252       };
14253     } catch (...) {
14254       {
14255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14256       };
14257     }
14258   }
14259
14260   jresult = result;
14261   return jresult;
14262 }
14263
14264
14265 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
14266   unsigned int jresult ;
14267   float arg1 ;
14268   float arg2 ;
14269   bool result;
14270
14271   arg1 = (float)jarg1;
14272   arg2 = (float)jarg2;
14273   {
14274     try {
14275       result = (bool)Dali::Equals(arg1,arg2);
14276     } catch (std::out_of_range& e) {
14277       {
14278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14279       };
14280     } catch (std::exception& e) {
14281       {
14282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14283       };
14284     } catch (Dali::DaliException e) {
14285       {
14286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14287       };
14288     } catch (...) {
14289       {
14290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14291       };
14292     }
14293   }
14294
14295   jresult = result;
14296   return jresult;
14297 }
14298
14299
14300 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
14301   unsigned int jresult ;
14302   float arg1 ;
14303   float arg2 ;
14304   float arg3 ;
14305   bool result;
14306
14307   arg1 = (float)jarg1;
14308   arg2 = (float)jarg2;
14309   arg3 = (float)jarg3;
14310   {
14311     try {
14312       result = (bool)Dali::Equals(arg1,arg2,arg3);
14313     } catch (std::out_of_range& e) {
14314       {
14315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14316       };
14317     } catch (std::exception& e) {
14318       {
14319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14320       };
14321     } catch (Dali::DaliException e) {
14322       {
14323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14324       };
14325     } catch (...) {
14326       {
14327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14328       };
14329     }
14330   }
14331
14332   jresult = result;
14333   return jresult;
14334 }
14335
14336
14337 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
14338   float jresult ;
14339   float arg1 ;
14340   int arg2 ;
14341   float result;
14342
14343   arg1 = (float)jarg1;
14344   arg2 = (int)jarg2;
14345   {
14346     try {
14347       result = (float)Dali::Round(arg1,arg2);
14348     } catch (std::out_of_range& e) {
14349       {
14350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14351       };
14352     } catch (std::exception& e) {
14353       {
14354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14355       };
14356     } catch (Dali::DaliException e) {
14357       {
14358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14359       };
14360     } catch (...) {
14361       {
14362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14363       };
14364     }
14365   }
14366
14367   jresult = result;
14368   return jresult;
14369 }
14370
14371
14372 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
14373   float jresult ;
14374   float arg1 ;
14375   float arg2 ;
14376   float arg3 ;
14377   float result;
14378
14379   arg1 = (float)jarg1;
14380   arg2 = (float)jarg2;
14381   arg3 = (float)jarg3;
14382   {
14383     try {
14384       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
14385     } catch (std::out_of_range& e) {
14386       {
14387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14388       };
14389     } catch (std::exception& e) {
14390       {
14391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14392       };
14393     } catch (Dali::DaliException e) {
14394       {
14395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14396       };
14397     } catch (...) {
14398       {
14399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14400       };
14401     }
14402   }
14403
14404   jresult = result;
14405   return jresult;
14406 }
14407
14408
14409 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
14410   float jresult ;
14411   float arg1 ;
14412   float arg2 ;
14413   float arg3 ;
14414   float arg4 ;
14415   float result;
14416
14417   arg1 = (float)jarg1;
14418   arg2 = (float)jarg2;
14419   arg3 = (float)jarg3;
14420   arg4 = (float)jarg4;
14421   {
14422     try {
14423       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
14424     } catch (std::out_of_range& e) {
14425       {
14426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14427       };
14428     } catch (std::exception& e) {
14429       {
14430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14431       };
14432     } catch (Dali::DaliException e) {
14433       {
14434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14435       };
14436     } catch (...) {
14437       {
14438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14439       };
14440     }
14441   }
14442
14443   jresult = result;
14444   return jresult;
14445 }
14446
14447
14448 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
14449   int jresult ;
14450   int result;
14451
14452   result = (int)(int)Dali::Property::INVALID_INDEX;
14453   jresult = result;
14454   return jresult;
14455 }
14456
14457
14458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
14459   int jresult ;
14460   int result;
14461
14462   result = (int)(int)Dali::Property::INVALID_KEY;
14463   jresult = result;
14464   return jresult;
14465 }
14466
14467
14468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
14469   int jresult ;
14470   int result;
14471
14472   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
14473   jresult = result;
14474   return jresult;
14475 }
14476
14477
14478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
14479   void * jresult ;
14480   Dali::Handle *arg1 = 0 ;
14481   Dali::Property::Index arg2 ;
14482   Dali::Property *result = 0 ;
14483
14484   arg1 = (Dali::Handle *)jarg1;
14485   if (!arg1) {
14486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14487     return 0;
14488   }
14489   arg2 = (Dali::Property::Index)jarg2;
14490   {
14491     try {
14492       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
14493     } catch (std::out_of_range& e) {
14494       {
14495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14496       };
14497     } catch (std::exception& e) {
14498       {
14499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14500       };
14501     } catch (Dali::DaliException e) {
14502       {
14503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14504       };
14505     } catch (...) {
14506       {
14507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14508       };
14509     }
14510   }
14511
14512   jresult = (void *)result;
14513   return jresult;
14514 }
14515
14516
14517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
14518   void * jresult ;
14519   Dali::Handle *arg1 = 0 ;
14520   Dali::Property::Index arg2 ;
14521   int arg3 ;
14522   Dali::Property *result = 0 ;
14523
14524   arg1 = (Dali::Handle *)jarg1;
14525   if (!arg1) {
14526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14527     return 0;
14528   }
14529   arg2 = (Dali::Property::Index)jarg2;
14530   arg3 = (int)jarg3;
14531   {
14532     try {
14533       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
14534     } catch (std::out_of_range& e) {
14535       {
14536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14537       };
14538     } catch (std::exception& e) {
14539       {
14540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14541       };
14542     } catch (Dali::DaliException e) {
14543       {
14544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14545       };
14546     } catch (...) {
14547       {
14548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14549       };
14550     }
14551   }
14552
14553   jresult = (void *)result;
14554   return jresult;
14555 }
14556
14557
14558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
14559   void * jresult ;
14560   Dali::Handle *arg1 = 0 ;
14561   std::string *arg2 = 0 ;
14562   Dali::Property *result = 0 ;
14563
14564   arg1 = (Dali::Handle *)jarg1;
14565   if (!arg1) {
14566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14567     return 0;
14568   }
14569   if (!jarg2) {
14570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14571     return 0;
14572   }
14573   std::string arg2_str(jarg2);
14574   arg2 = &arg2_str;
14575   {
14576     try {
14577       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
14578     } catch (std::out_of_range& e) {
14579       {
14580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14581       };
14582     } catch (std::exception& e) {
14583       {
14584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14585       };
14586     } catch (Dali::DaliException e) {
14587       {
14588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14589       };
14590     } catch (...) {
14591       {
14592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14593       };
14594     }
14595   }
14596
14597   jresult = (void *)result;
14598
14599   //argout typemap for const std::string&
14600
14601   return jresult;
14602 }
14603
14604
14605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
14606   void * jresult ;
14607   Dali::Handle *arg1 = 0 ;
14608   std::string *arg2 = 0 ;
14609   int arg3 ;
14610   Dali::Property *result = 0 ;
14611
14612   arg1 = (Dali::Handle *)jarg1;
14613   if (!arg1) {
14614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14615     return 0;
14616   }
14617   if (!jarg2) {
14618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14619     return 0;
14620   }
14621   std::string arg2_str(jarg2);
14622   arg2 = &arg2_str;
14623   arg3 = (int)jarg3;
14624   {
14625     try {
14626       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
14627     } catch (std::out_of_range& e) {
14628       {
14629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14630       };
14631     } catch (std::exception& e) {
14632       {
14633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14634       };
14635     } catch (Dali::DaliException e) {
14636       {
14637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14638       };
14639     } catch (...) {
14640       {
14641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14642       };
14643     }
14644   }
14645
14646   jresult = (void *)result;
14647
14648   //argout typemap for const std::string&
14649
14650   return jresult;
14651 }
14652
14653
14654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
14655   Dali::Property *arg1 = (Dali::Property *) 0 ;
14656
14657   arg1 = (Dali::Property *)jarg1;
14658   {
14659     try {
14660       delete arg1;
14661     } catch (std::out_of_range& e) {
14662       {
14663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14664       };
14665     } catch (std::exception& e) {
14666       {
14667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14668       };
14669     } catch (Dali::DaliException e) {
14670       {
14671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14672       };
14673     } catch (...) {
14674       {
14675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14676       };
14677     }
14678   }
14679
14680 }
14681
14682
14683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
14684   Dali::Property *arg1 = (Dali::Property *) 0 ;
14685   Dali::Handle *arg2 = 0 ;
14686
14687   arg1 = (Dali::Property *)jarg1;
14688   arg2 = (Dali::Handle *)jarg2;
14689   if (!arg2) {
14690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14691     return ;
14692   }
14693   if (arg1) (arg1)->object = *arg2;
14694 }
14695
14696
14697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
14698   void * jresult ;
14699   Dali::Property *arg1 = (Dali::Property *) 0 ;
14700   Dali::Handle *result = 0 ;
14701
14702   arg1 = (Dali::Property *)jarg1;
14703   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
14704   jresult = (void *)result;
14705   return jresult;
14706 }
14707
14708
14709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
14710   Dali::Property *arg1 = (Dali::Property *) 0 ;
14711   Dali::Property::Index arg2 ;
14712
14713   arg1 = (Dali::Property *)jarg1;
14714   arg2 = (Dali::Property::Index)jarg2;
14715   if (arg1) (arg1)->propertyIndex = arg2;
14716 }
14717
14718
14719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
14720   int jresult ;
14721   Dali::Property *arg1 = (Dali::Property *) 0 ;
14722   Dali::Property::Index result;
14723
14724   arg1 = (Dali::Property *)jarg1;
14725   result = (Dali::Property::Index) ((arg1)->propertyIndex);
14726   jresult = result;
14727   return jresult;
14728 }
14729
14730
14731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
14732   Dali::Property *arg1 = (Dali::Property *) 0 ;
14733   int arg2 ;
14734
14735   arg1 = (Dali::Property *)jarg1;
14736   arg2 = (int)jarg2;
14737   if (arg1) (arg1)->componentIndex = arg2;
14738 }
14739
14740
14741 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
14742   int jresult ;
14743   Dali::Property *arg1 = (Dali::Property *) 0 ;
14744   int result;
14745
14746   arg1 = (Dali::Property *)jarg1;
14747   result = (int) ((arg1)->componentIndex);
14748   jresult = result;
14749   return jresult;
14750 }
14751
14752
14753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
14754   void * jresult ;
14755   Dali::Property::Array *result = 0 ;
14756
14757   {
14758     try {
14759       result = (Dali::Property::Array *)new Dali::Property::Array();
14760     } catch (std::out_of_range& e) {
14761       {
14762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14763       };
14764     } catch (std::exception& e) {
14765       {
14766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14767       };
14768     } catch (Dali::DaliException e) {
14769       {
14770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14771       };
14772     } catch (...) {
14773       {
14774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14775       };
14776     }
14777   }
14778
14779   jresult = (void *)result;
14780   return jresult;
14781 }
14782
14783
14784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
14785   void * jresult ;
14786   Dali::Property::Array *arg1 = 0 ;
14787   Dali::Property::Array *result = 0 ;
14788
14789   arg1 = (Dali::Property::Array *)jarg1;
14790   if (!arg1) {
14791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
14792     return 0;
14793   }
14794   {
14795     try {
14796       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
14797     } catch (std::out_of_range& e) {
14798       {
14799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14800       };
14801     } catch (std::exception& e) {
14802       {
14803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14804       };
14805     } catch (Dali::DaliException e) {
14806       {
14807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14808       };
14809     } catch (...) {
14810       {
14811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14812       };
14813     }
14814   }
14815
14816   jresult = (void *)result;
14817   return jresult;
14818 }
14819
14820
14821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
14822   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14823
14824   arg1 = (Dali::Property::Array *)jarg1;
14825   {
14826     try {
14827       delete arg1;
14828     } catch (std::out_of_range& e) {
14829       {
14830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14831       };
14832     } catch (std::exception& e) {
14833       {
14834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14835       };
14836     } catch (Dali::DaliException e) {
14837       {
14838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14839       };
14840     } catch (...) {
14841       {
14842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14843       };
14844     }
14845   }
14846
14847 }
14848
14849
14850 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
14851   unsigned long jresult ;
14852   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14853   Dali::Property::Array::SizeType result;
14854
14855   arg1 = (Dali::Property::Array *)jarg1;
14856   {
14857     try {
14858       result = ((Dali::Property::Array const *)arg1)->Size();
14859     } catch (std::out_of_range& e) {
14860       {
14861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14862       };
14863     } catch (std::exception& e) {
14864       {
14865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14866       };
14867     } catch (Dali::DaliException e) {
14868       {
14869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14870       };
14871     } catch (...) {
14872       {
14873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14874       };
14875     }
14876   }
14877
14878   jresult = (unsigned long)result;
14879   return jresult;
14880 }
14881
14882
14883 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
14884   unsigned long jresult ;
14885   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14886   Dali::Property::Array::SizeType result;
14887
14888   arg1 = (Dali::Property::Array *)jarg1;
14889   {
14890     try {
14891       result = ((Dali::Property::Array const *)arg1)->Count();
14892     } catch (std::out_of_range& e) {
14893       {
14894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14895       };
14896     } catch (std::exception& e) {
14897       {
14898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14899       };
14900     } catch (Dali::DaliException e) {
14901       {
14902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14903       };
14904     } catch (...) {
14905       {
14906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14907       };
14908     }
14909   }
14910
14911   jresult = (unsigned long)result;
14912   return jresult;
14913 }
14914
14915
14916 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
14917   unsigned int jresult ;
14918   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14919   bool result;
14920
14921   arg1 = (Dali::Property::Array *)jarg1;
14922   {
14923     try {
14924       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
14925     } catch (std::out_of_range& e) {
14926       {
14927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14928       };
14929     } catch (std::exception& e) {
14930       {
14931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14932       };
14933     } catch (Dali::DaliException e) {
14934       {
14935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14936       };
14937     } catch (...) {
14938       {
14939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14940       };
14941     }
14942   }
14943
14944   jresult = result;
14945   return jresult;
14946 }
14947
14948
14949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
14950   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14951
14952   arg1 = (Dali::Property::Array *)jarg1;
14953   {
14954     try {
14955       (arg1)->Clear();
14956     } catch (std::out_of_range& e) {
14957       {
14958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14959       };
14960     } catch (std::exception& e) {
14961       {
14962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14963       };
14964     } catch (Dali::DaliException e) {
14965       {
14966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14967       };
14968     } catch (...) {
14969       {
14970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14971       };
14972     }
14973   }
14974
14975 }
14976
14977
14978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
14979   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14980   Dali::Property::Array::SizeType arg2 ;
14981
14982   arg1 = (Dali::Property::Array *)jarg1;
14983   arg2 = (Dali::Property::Array::SizeType)jarg2;
14984   {
14985     try {
14986       (arg1)->Reserve(arg2);
14987     } catch (std::out_of_range& e) {
14988       {
14989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14990       };
14991     } catch (std::exception& e) {
14992       {
14993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14994       };
14995     } catch (Dali::DaliException e) {
14996       {
14997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14998       };
14999     } catch (...) {
15000       {
15001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15002       };
15003     }
15004   }
15005
15006 }
15007
15008
15009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
15010   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15011   Dali::Property::Array::SizeType arg2 ;
15012
15013   arg1 = (Dali::Property::Array *)jarg1;
15014   arg2 = (Dali::Property::Array::SizeType)jarg2;
15015   {
15016     try {
15017       (arg1)->Resize(arg2);
15018     } catch (std::out_of_range& e) {
15019       {
15020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15021       };
15022     } catch (std::exception& e) {
15023       {
15024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15025       };
15026     } catch (Dali::DaliException e) {
15027       {
15028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15029       };
15030     } catch (...) {
15031       {
15032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15033       };
15034     }
15035   }
15036
15037 }
15038
15039
15040 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
15041   unsigned long jresult ;
15042   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15043   Dali::Property::Array::SizeType result;
15044
15045   arg1 = (Dali::Property::Array *)jarg1;
15046   {
15047     try {
15048       result = (arg1)->Capacity();
15049     } catch (std::out_of_range& e) {
15050       {
15051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15052       };
15053     } catch (std::exception& e) {
15054       {
15055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15056       };
15057     } catch (Dali::DaliException e) {
15058       {
15059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15060       };
15061     } catch (...) {
15062       {
15063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15064       };
15065     }
15066   }
15067
15068   jresult = (unsigned long)result;
15069   return jresult;
15070 }
15071
15072
15073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
15074   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15075   Dali::Property::Value *arg2 = 0 ;
15076
15077   arg1 = (Dali::Property::Array *)jarg1;
15078   arg2 = (Dali::Property::Value *)jarg2;
15079   if (!arg2) {
15080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15081     return ;
15082   }
15083   {
15084     try {
15085       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
15086     } catch (std::out_of_range& e) {
15087       {
15088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15089       };
15090     } catch (std::exception& e) {
15091       {
15092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15093       };
15094     } catch (Dali::DaliException e) {
15095       {
15096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15097       };
15098     } catch (...) {
15099       {
15100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15101       };
15102     }
15103   }
15104
15105 }
15106
15107
15108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
15109   void * jresult ;
15110   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15111   Dali::Property::Value *arg2 = 0 ;
15112   Dali::Property::Array *result = 0 ;
15113
15114   arg1 = (Dali::Property::Array *)jarg1;
15115   arg2 = (Dali::Property::Value *)jarg2;
15116   if (!arg2) {
15117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15118     return 0;
15119   }
15120   {
15121     try {
15122       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
15123     } catch (std::out_of_range& e) {
15124       {
15125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15126       };
15127     } catch (std::exception& e) {
15128       {
15129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15130       };
15131     } catch (Dali::DaliException e) {
15132       {
15133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15134       };
15135     } catch (...) {
15136       {
15137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15138       };
15139     }
15140   }
15141
15142   jresult = (void *)result;
15143   return jresult;
15144 }
15145
15146
15147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
15148   void * jresult ;
15149   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15150   Dali::Property::Array::SizeType arg2 ;
15151   Dali::Property::Value *result = 0 ;
15152
15153   arg1 = (Dali::Property::Array *)jarg1;
15154   arg2 = (Dali::Property::Array::SizeType)jarg2;
15155   {
15156     try {
15157       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
15158     } catch (std::out_of_range& e) {
15159       {
15160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15161       };
15162     } catch (std::exception& e) {
15163       {
15164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15165       };
15166     } catch (Dali::DaliException e) {
15167       {
15168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15169       };
15170     } catch (...) {
15171       {
15172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15173       };
15174     }
15175   }
15176
15177   jresult = (void *)result;
15178   return jresult;
15179 }
15180
15181
15182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
15183   void * jresult ;
15184   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15185   Dali::Property::Array::SizeType arg2 ;
15186   Dali::Property::Value *result = 0 ;
15187
15188   arg1 = (Dali::Property::Array *)jarg1;
15189   arg2 = (Dali::Property::Array::SizeType)jarg2;
15190   {
15191     try {
15192       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
15193     } catch (std::out_of_range& e) {
15194       {
15195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15196       };
15197     } catch (std::exception& e) {
15198       {
15199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15200       };
15201     } catch (Dali::DaliException e) {
15202       {
15203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15204       };
15205     } catch (...) {
15206       {
15207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15208       };
15209     }
15210   }
15211
15212   jresult = (void *)result;
15213   return jresult;
15214 }
15215
15216
15217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
15218   void * jresult ;
15219   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15220   Dali::Property::Array *arg2 = 0 ;
15221   Dali::Property::Array *result = 0 ;
15222
15223   arg1 = (Dali::Property::Array *)jarg1;
15224   arg2 = (Dali::Property::Array *)jarg2;
15225   if (!arg2) {
15226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
15227     return 0;
15228   }
15229   {
15230     try {
15231       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
15232     } catch (std::out_of_range& e) {
15233       {
15234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15235       };
15236     } catch (std::exception& e) {
15237       {
15238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15239       };
15240     } catch (Dali::DaliException e) {
15241       {
15242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15243       };
15244     } catch (...) {
15245       {
15246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15247       };
15248     }
15249   }
15250
15251   jresult = (void *)result;
15252   return jresult;
15253 }
15254
15255
15256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
15257   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15258   enum Dali::Property::Key::Type arg2 ;
15259
15260   arg1 = (Dali::Property::Key *)jarg1;
15261   arg2 = (enum Dali::Property::Key::Type)jarg2;
15262   if (arg1) (arg1)->type = arg2;
15263 }
15264
15265
15266 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
15267   int jresult ;
15268   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15269   enum Dali::Property::Key::Type result;
15270
15271   arg1 = (Dali::Property::Key *)jarg1;
15272   result = (enum Dali::Property::Key::Type) ((arg1)->type);
15273   jresult = (int)result;
15274   return jresult;
15275 }
15276
15277
15278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
15279   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15280   Dali::Property::Index arg2 ;
15281
15282   arg1 = (Dali::Property::Key *)jarg1;
15283   arg2 = (Dali::Property::Index)jarg2;
15284   if (arg1) (arg1)->indexKey = arg2;
15285 }
15286
15287
15288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
15289   int jresult ;
15290   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15291   Dali::Property::Index result;
15292
15293   arg1 = (Dali::Property::Key *)jarg1;
15294   result = (Dali::Property::Index) ((arg1)->indexKey);
15295   jresult = result;
15296   return jresult;
15297 }
15298
15299
15300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
15301   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15302   std::string *arg2 = 0 ;
15303
15304   arg1 = (Dali::Property::Key *)jarg1;
15305   if (!jarg2) {
15306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15307     return ;
15308   }
15309   std::string arg2_str(jarg2);
15310   arg2 = &arg2_str;
15311   if (arg1) (arg1)->stringKey = *arg2;
15312
15313   //argout typemap for const std::string&
15314
15315 }
15316
15317
15318 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
15319   char * jresult ;
15320   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15321   std::string *result = 0 ;
15322
15323   arg1 = (Dali::Property::Key *)jarg1;
15324   result = (std::string *) & ((arg1)->stringKey);
15325   jresult = SWIG_csharp_string_callback(result->c_str());
15326   return jresult;
15327 }
15328
15329
15330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
15331   void * jresult ;
15332   std::string *arg1 = 0 ;
15333   Dali::Property::Key *result = 0 ;
15334
15335   if (!jarg1) {
15336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15337     return 0;
15338   }
15339   std::string arg1_str(jarg1);
15340   arg1 = &arg1_str;
15341   {
15342     try {
15343       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
15344     } catch (std::out_of_range& e) {
15345       {
15346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15347       };
15348     } catch (std::exception& e) {
15349       {
15350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15351       };
15352     } catch (Dali::DaliException e) {
15353       {
15354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15355       };
15356     } catch (...) {
15357       {
15358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15359       };
15360     }
15361   }
15362
15363   jresult = (void *)result;
15364
15365   //argout typemap for const std::string&
15366
15367   return jresult;
15368 }
15369
15370
15371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
15372   void * jresult ;
15373   Dali::Property::Index arg1 ;
15374   Dali::Property::Key *result = 0 ;
15375
15376   arg1 = (Dali::Property::Index)jarg1;
15377   {
15378     try {
15379       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
15380     } catch (std::out_of_range& e) {
15381       {
15382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15383       };
15384     } catch (std::exception& e) {
15385       {
15386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15387       };
15388     } catch (Dali::DaliException e) {
15389       {
15390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15391       };
15392     } catch (...) {
15393       {
15394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15395       };
15396     }
15397   }
15398
15399   jresult = (void *)result;
15400   return jresult;
15401 }
15402
15403
15404 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
15405   unsigned int jresult ;
15406   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15407   std::string *arg2 = 0 ;
15408   bool result;
15409
15410   arg1 = (Dali::Property::Key *)jarg1;
15411   if (!jarg2) {
15412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15413     return 0;
15414   }
15415   std::string arg2_str(jarg2);
15416   arg2 = &arg2_str;
15417   {
15418     try {
15419       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
15420     } catch (std::out_of_range& e) {
15421       {
15422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15423       };
15424     } catch (std::exception& e) {
15425       {
15426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15427       };
15428     } catch (Dali::DaliException e) {
15429       {
15430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15431       };
15432     } catch (...) {
15433       {
15434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15435       };
15436     }
15437   }
15438
15439   jresult = result;
15440
15441   //argout typemap for const std::string&
15442
15443   return jresult;
15444 }
15445
15446
15447 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
15448   unsigned int jresult ;
15449   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15450   Dali::Property::Index arg2 ;
15451   bool result;
15452
15453   arg1 = (Dali::Property::Key *)jarg1;
15454   arg2 = (Dali::Property::Index)jarg2;
15455   {
15456     try {
15457       result = (bool)(arg1)->operator ==(arg2);
15458     } catch (std::out_of_range& e) {
15459       {
15460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15461       };
15462     } catch (std::exception& e) {
15463       {
15464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15465       };
15466     } catch (Dali::DaliException e) {
15467       {
15468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15469       };
15470     } catch (...) {
15471       {
15472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15473       };
15474     }
15475   }
15476
15477   jresult = result;
15478   return jresult;
15479 }
15480
15481
15482 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
15483   unsigned int jresult ;
15484   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15485   Dali::Property::Key *arg2 = 0 ;
15486   bool result;
15487
15488   arg1 = (Dali::Property::Key *)jarg1;
15489   arg2 = (Dali::Property::Key *)jarg2;
15490   if (!arg2) {
15491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15492     return 0;
15493   }
15494   {
15495     try {
15496       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
15497     } catch (std::out_of_range& e) {
15498       {
15499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15500       };
15501     } catch (std::exception& e) {
15502       {
15503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15504       };
15505     } catch (Dali::DaliException e) {
15506       {
15507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15508       };
15509     } catch (...) {
15510       {
15511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15512       };
15513     }
15514   }
15515
15516   jresult = result;
15517   return jresult;
15518 }
15519
15520
15521 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
15522   unsigned int jresult ;
15523   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15524   std::string *arg2 = 0 ;
15525   bool result;
15526
15527   arg1 = (Dali::Property::Key *)jarg1;
15528   if (!jarg2) {
15529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15530     return 0;
15531   }
15532   std::string arg2_str(jarg2);
15533   arg2 = &arg2_str;
15534   {
15535     try {
15536       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
15537     } catch (std::out_of_range& e) {
15538       {
15539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15540       };
15541     } catch (std::exception& e) {
15542       {
15543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15544       };
15545     } catch (Dali::DaliException e) {
15546       {
15547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15548       };
15549     } catch (...) {
15550       {
15551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15552       };
15553     }
15554   }
15555
15556   jresult = result;
15557
15558   //argout typemap for const std::string&
15559
15560   return jresult;
15561 }
15562
15563
15564 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
15565   unsigned int jresult ;
15566   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15567   Dali::Property::Index arg2 ;
15568   bool result;
15569
15570   arg1 = (Dali::Property::Key *)jarg1;
15571   arg2 = (Dali::Property::Index)jarg2;
15572   {
15573     try {
15574       result = (bool)(arg1)->operator !=(arg2);
15575     } catch (std::out_of_range& e) {
15576       {
15577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15578       };
15579     } catch (std::exception& e) {
15580       {
15581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15582       };
15583     } catch (Dali::DaliException e) {
15584       {
15585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15586       };
15587     } catch (...) {
15588       {
15589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15590       };
15591     }
15592   }
15593
15594   jresult = result;
15595   return jresult;
15596 }
15597
15598
15599 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
15600   unsigned int jresult ;
15601   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15602   Dali::Property::Key *arg2 = 0 ;
15603   bool result;
15604
15605   arg1 = (Dali::Property::Key *)jarg1;
15606   arg2 = (Dali::Property::Key *)jarg2;
15607   if (!arg2) {
15608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15609     return 0;
15610   }
15611   {
15612     try {
15613       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
15614     } catch (std::out_of_range& e) {
15615       {
15616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15617       };
15618     } catch (std::exception& e) {
15619       {
15620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15621       };
15622     } catch (Dali::DaliException e) {
15623       {
15624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15625       };
15626     } catch (...) {
15627       {
15628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15629       };
15630     }
15631   }
15632
15633   jresult = result;
15634   return jresult;
15635 }
15636
15637
15638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
15639   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15640
15641   arg1 = (Dali::Property::Key *)jarg1;
15642   {
15643     try {
15644       delete arg1;
15645     } catch (std::out_of_range& e) {
15646       {
15647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15648       };
15649     } catch (std::exception& e) {
15650       {
15651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15652       };
15653     } catch (Dali::DaliException e) {
15654       {
15655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15656       };
15657     } catch (...) {
15658       {
15659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15660       };
15661     }
15662   }
15663
15664 }
15665
15666
15667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
15668   void * jresult ;
15669   Dali::Property::Map *result = 0 ;
15670
15671   {
15672     try {
15673       result = (Dali::Property::Map *)new Dali::Property::Map();
15674     } catch (std::out_of_range& e) {
15675       {
15676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15677       };
15678     } catch (std::exception& e) {
15679       {
15680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15681       };
15682     } catch (Dali::DaliException e) {
15683       {
15684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15685       };
15686     } catch (...) {
15687       {
15688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15689       };
15690     }
15691   }
15692
15693   jresult = (void *)result;
15694   return jresult;
15695 }
15696
15697
15698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
15699   void * jresult ;
15700   Dali::Property::Map *arg1 = 0 ;
15701   Dali::Property::Map *result = 0 ;
15702
15703   arg1 = (Dali::Property::Map *)jarg1;
15704   if (!arg1) {
15705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15706     return 0;
15707   }
15708   {
15709     try {
15710       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
15711     } catch (std::out_of_range& e) {
15712       {
15713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15714       };
15715     } catch (std::exception& e) {
15716       {
15717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15718       };
15719     } catch (Dali::DaliException e) {
15720       {
15721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15722       };
15723     } catch (...) {
15724       {
15725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15726       };
15727     }
15728   }
15729
15730   jresult = (void *)result;
15731   return jresult;
15732 }
15733
15734
15735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
15736   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15737
15738   arg1 = (Dali::Property::Map *)jarg1;
15739   {
15740     try {
15741       delete arg1;
15742     } catch (std::out_of_range& e) {
15743       {
15744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15745       };
15746     } catch (std::exception& e) {
15747       {
15748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15749       };
15750     } catch (Dali::DaliException e) {
15751       {
15752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15753       };
15754     } catch (...) {
15755       {
15756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15757       };
15758     }
15759   }
15760
15761 }
15762
15763
15764 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
15765   unsigned long jresult ;
15766   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15767   Dali::Property::Map::SizeType result;
15768
15769   arg1 = (Dali::Property::Map *)jarg1;
15770   {
15771     try {
15772       result = ((Dali::Property::Map const *)arg1)->Count();
15773     } catch (std::out_of_range& e) {
15774       {
15775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15776       };
15777     } catch (std::exception& e) {
15778       {
15779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15780       };
15781     } catch (Dali::DaliException e) {
15782       {
15783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15784       };
15785     } catch (...) {
15786       {
15787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15788       };
15789     }
15790   }
15791
15792   jresult = (unsigned long)result;
15793   return jresult;
15794 }
15795
15796
15797 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
15798   unsigned int jresult ;
15799   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15800   bool result;
15801
15802   arg1 = (Dali::Property::Map *)jarg1;
15803   {
15804     try {
15805       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
15806     } catch (std::out_of_range& e) {
15807       {
15808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15809       };
15810     } catch (std::exception& e) {
15811       {
15812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15813       };
15814     } catch (Dali::DaliException e) {
15815       {
15816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15817       };
15818     } catch (...) {
15819       {
15820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15821       };
15822     }
15823   }
15824
15825   jresult = result;
15826   return jresult;
15827 }
15828
15829
15830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15831   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15832   char *arg2 = (char *) 0 ;
15833   Dali::Property::Value *arg3 = 0 ;
15834
15835   arg1 = (Dali::Property::Map *)jarg1;
15836   arg2 = (char *)jarg2;
15837   arg3 = (Dali::Property::Value *)jarg3;
15838   if (!arg3) {
15839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15840     return ;
15841   }
15842   {
15843     try {
15844       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
15845     } catch (std::out_of_range& e) {
15846       {
15847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15848       };
15849     } catch (std::exception& e) {
15850       {
15851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15852       };
15853     } catch (Dali::DaliException e) {
15854       {
15855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15856       };
15857     } catch (...) {
15858       {
15859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15860       };
15861     }
15862   }
15863
15864 }
15865
15866
15867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
15868   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15869   Dali::Property::Index arg2 ;
15870   Dali::Property::Value *arg3 = 0 ;
15871
15872   arg1 = (Dali::Property::Map *)jarg1;
15873   arg2 = (Dali::Property::Index)jarg2;
15874   arg3 = (Dali::Property::Value *)jarg3;
15875   if (!arg3) {
15876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15877     return ;
15878   }
15879   {
15880     try {
15881       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
15882     } catch (std::out_of_range& e) {
15883       {
15884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15885       };
15886     } catch (std::exception& e) {
15887       {
15888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15889       };
15890     } catch (Dali::DaliException e) {
15891       {
15892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15893       };
15894     } catch (...) {
15895       {
15896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15897       };
15898     }
15899   }
15900
15901 }
15902
15903
15904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15905   void * jresult ;
15906   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15907   char *arg2 = (char *) 0 ;
15908   Dali::Property::Value *arg3 = 0 ;
15909   Dali::Property::Map *result = 0 ;
15910
15911   arg1 = (Dali::Property::Map *)jarg1;
15912   arg2 = (char *)jarg2;
15913   arg3 = (Dali::Property::Value *)jarg3;
15914   if (!arg3) {
15915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15916     return 0;
15917   }
15918   {
15919     try {
15920       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
15921     } catch (std::out_of_range& e) {
15922       {
15923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15924       };
15925     } catch (std::exception& e) {
15926       {
15927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15928       };
15929     } catch (Dali::DaliException e) {
15930       {
15931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15932       };
15933     } catch (...) {
15934       {
15935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15936       };
15937     }
15938   }
15939
15940   jresult = (void *)result;
15941   return jresult;
15942 }
15943
15944
15945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
15946   void * jresult ;
15947   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15948   Dali::Property::Index arg2 ;
15949   Dali::Property::Value *arg3 = 0 ;
15950   Dali::Property::Map *result = 0 ;
15951
15952   arg1 = (Dali::Property::Map *)jarg1;
15953   arg2 = (Dali::Property::Index)jarg2;
15954   arg3 = (Dali::Property::Value *)jarg3;
15955   if (!arg3) {
15956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15957     return 0;
15958   }
15959   {
15960     try {
15961       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
15962     } catch (std::out_of_range& e) {
15963       {
15964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15965       };
15966     } catch (std::exception& e) {
15967       {
15968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15969       };
15970     } catch (Dali::DaliException e) {
15971       {
15972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15973       };
15974     } catch (...) {
15975       {
15976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15977       };
15978     }
15979   }
15980
15981   jresult = (void *)result;
15982   return jresult;
15983 }
15984
15985
15986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
15987   void * jresult ;
15988   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15989   Dali::Property::Map::SizeType arg2 ;
15990   Dali::Property::Value *result = 0 ;
15991
15992   arg1 = (Dali::Property::Map *)jarg1;
15993   arg2 = (Dali::Property::Map::SizeType)jarg2;
15994   {
15995     try {
15996       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
15997     } catch (std::out_of_range& e) {
15998       {
15999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16000       };
16001     } catch (std::exception& e) {
16002       {
16003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16004       };
16005     } catch (Dali::DaliException e) {
16006       {
16007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16008       };
16009     } catch (...) {
16010       {
16011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16012       };
16013     }
16014   }
16015
16016   jresult = (void *)result;
16017   return jresult;
16018 }
16019
16020
16021 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
16022   char * jresult ;
16023   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16024   Dali::Property::Map::SizeType arg2 ;
16025   std::string *result = 0 ;
16026
16027   arg1 = (Dali::Property::Map *)jarg1;
16028   arg2 = (Dali::Property::Map::SizeType)jarg2;
16029   {
16030     try {
16031       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
16032     } catch (std::out_of_range& e) {
16033       {
16034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16035       };
16036     } catch (std::exception& e) {
16037       {
16038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16039       };
16040     } catch (Dali::DaliException e) {
16041       {
16042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16043       };
16044     } catch (...) {
16045       {
16046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16047       };
16048     }
16049   }
16050
16051   jresult = SWIG_csharp_string_callback(result->c_str());
16052   return jresult;
16053 }
16054
16055
16056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
16057   void * jresult ;
16058   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16059   Dali::Property::Map::SizeType arg2 ;
16060   SwigValueWrapper< Dali::Property::Key > result;
16061
16062   arg1 = (Dali::Property::Map *)jarg1;
16063   arg2 = (Dali::Property::Map::SizeType)jarg2;
16064   {
16065     try {
16066       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
16067     } catch (std::out_of_range& e) {
16068       {
16069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16070       };
16071     } catch (std::exception& e) {
16072       {
16073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16074       };
16075     } catch (Dali::DaliException e) {
16076       {
16077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16078       };
16079     } catch (...) {
16080       {
16081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16082       };
16083     }
16084   }
16085
16086   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
16087   return jresult;
16088 }
16089
16090
16091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
16092   void * jresult ;
16093   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16094   Dali::Property::Map::SizeType arg2 ;
16095   StringValuePair *result = 0 ;
16096
16097   arg1 = (Dali::Property::Map *)jarg1;
16098   arg2 = (Dali::Property::Map::SizeType)jarg2;
16099   {
16100     try {
16101       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
16102     } catch (std::out_of_range& e) {
16103       {
16104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16105       };
16106     } catch (std::exception& e) {
16107       {
16108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16109       };
16110     } catch (Dali::DaliException e) {
16111       {
16112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16113       };
16114     } catch (...) {
16115       {
16116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16117       };
16118     }
16119   }
16120
16121   jresult = (void *)result;
16122   return jresult;
16123 }
16124
16125
16126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
16127   void * jresult ;
16128   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16129   char *arg2 = (char *) 0 ;
16130   Dali::Property::Value *result = 0 ;
16131
16132   arg1 = (Dali::Property::Map *)jarg1;
16133   arg2 = (char *)jarg2;
16134   {
16135     try {
16136       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
16137     } catch (std::out_of_range& e) {
16138       {
16139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16140       };
16141     } catch (std::exception& e) {
16142       {
16143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16144       };
16145     } catch (Dali::DaliException e) {
16146       {
16147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16148       };
16149     } catch (...) {
16150       {
16151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16152       };
16153     }
16154   }
16155
16156   jresult = (void *)result;
16157   return jresult;
16158 }
16159
16160
16161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
16162   void * jresult ;
16163   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16164   Dali::Property::Index arg2 ;
16165   Dali::Property::Value *result = 0 ;
16166
16167   arg1 = (Dali::Property::Map *)jarg1;
16168   arg2 = (Dali::Property::Index)jarg2;
16169   {
16170     try {
16171       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
16172     } catch (std::out_of_range& e) {
16173       {
16174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16175       };
16176     } catch (std::exception& e) {
16177       {
16178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16179       };
16180     } catch (Dali::DaliException e) {
16181       {
16182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16183       };
16184     } catch (...) {
16185       {
16186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16187       };
16188     }
16189   }
16190
16191   jresult = (void *)result;
16192   return jresult;
16193 }
16194
16195
16196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
16197   void * jresult ;
16198   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16199   Dali::Property::Index arg2 ;
16200   std::string *arg3 = 0 ;
16201   Dali::Property::Value *result = 0 ;
16202
16203   arg1 = (Dali::Property::Map *)jarg1;
16204   arg2 = (Dali::Property::Index)jarg2;
16205   if (!jarg3) {
16206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16207     return 0;
16208   }
16209   std::string arg3_str(jarg3);
16210   arg3 = &arg3_str;
16211   {
16212     try {
16213       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
16214     } catch (std::out_of_range& e) {
16215       {
16216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16217       };
16218     } catch (std::exception& e) {
16219       {
16220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16221       };
16222     } catch (Dali::DaliException e) {
16223       {
16224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16225       };
16226     } catch (...) {
16227       {
16228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16229       };
16230     }
16231   }
16232
16233   jresult = (void *)result;
16234
16235   //argout typemap for const std::string&
16236
16237   return jresult;
16238 }
16239
16240
16241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
16242   void * jresult ;
16243   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16244   std::string *arg2 = 0 ;
16245   Dali::Property::Type arg3 ;
16246   Dali::Property::Value *result = 0 ;
16247
16248   arg1 = (Dali::Property::Map *)jarg1;
16249   if (!jarg2) {
16250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16251     return 0;
16252   }
16253   std::string arg2_str(jarg2);
16254   arg2 = &arg2_str;
16255   arg3 = (Dali::Property::Type)jarg3;
16256   {
16257     try {
16258       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
16259     } catch (std::out_of_range& e) {
16260       {
16261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16262       };
16263     } catch (std::exception& e) {
16264       {
16265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16266       };
16267     } catch (Dali::DaliException e) {
16268       {
16269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16270       };
16271     } catch (...) {
16272       {
16273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16274       };
16275     }
16276   }
16277
16278   jresult = (void *)result;
16279
16280   //argout typemap for const std::string&
16281
16282   return jresult;
16283 }
16284
16285
16286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
16287   void * jresult ;
16288   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16289   Dali::Property::Index arg2 ;
16290   Dali::Property::Type arg3 ;
16291   Dali::Property::Value *result = 0 ;
16292
16293   arg1 = (Dali::Property::Map *)jarg1;
16294   arg2 = (Dali::Property::Index)jarg2;
16295   arg3 = (Dali::Property::Type)jarg3;
16296   {
16297     try {
16298       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
16299     } catch (std::out_of_range& e) {
16300       {
16301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16302       };
16303     } catch (std::exception& e) {
16304       {
16305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16306       };
16307     } catch (Dali::DaliException e) {
16308       {
16309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16310       };
16311     } catch (...) {
16312       {
16313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16314       };
16315     }
16316   }
16317
16318   jresult = (void *)result;
16319   return jresult;
16320 }
16321
16322
16323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
16324   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16325
16326   arg1 = (Dali::Property::Map *)jarg1;
16327   {
16328     try {
16329       (arg1)->Clear();
16330     } catch (std::out_of_range& e) {
16331       {
16332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16333       };
16334     } catch (std::exception& e) {
16335       {
16336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16337       };
16338     } catch (Dali::DaliException e) {
16339       {
16340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16341       };
16342     } catch (...) {
16343       {
16344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16345       };
16346     }
16347   }
16348
16349 }
16350
16351
16352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
16353   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16354   Dali::Property::Map *arg2 = 0 ;
16355
16356   arg1 = (Dali::Property::Map *)jarg1;
16357   arg2 = (Dali::Property::Map *)jarg2;
16358   if (!arg2) {
16359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16360     return ;
16361   }
16362   {
16363     try {
16364       (arg1)->Merge((Dali::Property::Map const &)*arg2);
16365     } catch (std::out_of_range& e) {
16366       {
16367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16368       };
16369     } catch (std::exception& e) {
16370       {
16371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16372       };
16373     } catch (Dali::DaliException e) {
16374       {
16375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16376       };
16377     } catch (...) {
16378       {
16379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16380       };
16381     }
16382   }
16383
16384 }
16385
16386
16387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
16388   void * jresult ;
16389   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16390   std::string *arg2 = 0 ;
16391   Dali::Property::Value *result = 0 ;
16392
16393   arg1 = (Dali::Property::Map *)jarg1;
16394   if (!jarg2) {
16395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16396     return 0;
16397   }
16398   std::string arg2_str(jarg2);
16399   arg2 = &arg2_str;
16400   {
16401     try {
16402       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
16403     } catch (std::out_of_range& e) {
16404       {
16405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16406       };
16407     } catch (std::exception& e) {
16408       {
16409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16410       };
16411     } catch (Dali::DaliException e) {
16412       {
16413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16414       };
16415     } catch (...) {
16416       {
16417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16418       };
16419     }
16420   }
16421
16422   jresult = (void *)result;
16423
16424   //argout typemap for const std::string&
16425
16426   return jresult;
16427 }
16428
16429
16430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
16431   void * jresult ;
16432   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16433   Dali::Property::Index arg2 ;
16434   Dali::Property::Value *result = 0 ;
16435
16436   arg1 = (Dali::Property::Map *)jarg1;
16437   arg2 = (Dali::Property::Index)jarg2;
16438   {
16439     try {
16440       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
16441     } catch (std::out_of_range& e) {
16442       {
16443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16444       };
16445     } catch (std::exception& e) {
16446       {
16447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16448       };
16449     } catch (Dali::DaliException e) {
16450       {
16451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16452       };
16453     } catch (...) {
16454       {
16455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16456       };
16457     }
16458   }
16459
16460   jresult = (void *)result;
16461   return jresult;
16462 }
16463
16464
16465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
16466   void * jresult ;
16467   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16468   Dali::Property::Map *arg2 = 0 ;
16469   Dali::Property::Map *result = 0 ;
16470
16471   arg1 = (Dali::Property::Map *)jarg1;
16472   arg2 = (Dali::Property::Map *)jarg2;
16473   if (!arg2) {
16474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16475     return 0;
16476   }
16477   {
16478     try {
16479       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
16480     } catch (std::out_of_range& e) {
16481       {
16482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16483       };
16484     } catch (std::exception& e) {
16485       {
16486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16487       };
16488     } catch (Dali::DaliException e) {
16489       {
16490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16491       };
16492     } catch (...) {
16493       {
16494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16495       };
16496     }
16497   }
16498
16499   jresult = (void *)result;
16500   return jresult;
16501 }
16502
16503
16504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
16505   void * jresult ;
16506   Dali::Property::Value *result = 0 ;
16507
16508   {
16509     try {
16510       result = (Dali::Property::Value *)new Dali::Property::Value();
16511     } catch (std::out_of_range& e) {
16512       {
16513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16514       };
16515     } catch (std::exception& e) {
16516       {
16517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16518       };
16519     } catch (Dali::DaliException e) {
16520       {
16521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16522       };
16523     } catch (...) {
16524       {
16525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16526       };
16527     }
16528   }
16529
16530   jresult = (void *)result;
16531   return jresult;
16532 }
16533
16534
16535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
16536   void * jresult ;
16537   bool arg1 ;
16538   Dali::Property::Value *result = 0 ;
16539
16540   arg1 = jarg1 ? true : false;
16541   {
16542     try {
16543       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16544     } catch (std::out_of_range& e) {
16545       {
16546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16547       };
16548     } catch (std::exception& e) {
16549       {
16550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16551       };
16552     } catch (Dali::DaliException e) {
16553       {
16554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16555       };
16556     } catch (...) {
16557       {
16558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16559       };
16560     }
16561   }
16562
16563   jresult = (void *)result;
16564   return jresult;
16565 }
16566
16567
16568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
16569   void * jresult ;
16570   int arg1 ;
16571   Dali::Property::Value *result = 0 ;
16572
16573   arg1 = (int)jarg1;
16574   {
16575     try {
16576       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16577     } catch (std::out_of_range& e) {
16578       {
16579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16580       };
16581     } catch (std::exception& e) {
16582       {
16583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16584       };
16585     } catch (Dali::DaliException e) {
16586       {
16587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16588       };
16589     } catch (...) {
16590       {
16591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16592       };
16593     }
16594   }
16595
16596   jresult = (void *)result;
16597   return jresult;
16598 }
16599
16600
16601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
16602   void * jresult ;
16603   float arg1 ;
16604   Dali::Property::Value *result = 0 ;
16605
16606   arg1 = (float)jarg1;
16607   {
16608     try {
16609       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16610     } catch (std::out_of_range& e) {
16611       {
16612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16613       };
16614     } catch (std::exception& e) {
16615       {
16616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16617       };
16618     } catch (Dali::DaliException e) {
16619       {
16620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16621       };
16622     } catch (...) {
16623       {
16624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16625       };
16626     }
16627   }
16628
16629   jresult = (void *)result;
16630   return jresult;
16631 }
16632
16633
16634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
16635   void * jresult ;
16636   Dali::Vector2 *arg1 = 0 ;
16637   Dali::Property::Value *result = 0 ;
16638
16639   arg1 = (Dali::Vector2 *)jarg1;
16640   if (!arg1) {
16641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
16642     return 0;
16643   }
16644   {
16645     try {
16646       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
16647     } catch (std::out_of_range& e) {
16648       {
16649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16650       };
16651     } catch (std::exception& e) {
16652       {
16653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16654       };
16655     } catch (Dali::DaliException e) {
16656       {
16657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16658       };
16659     } catch (...) {
16660       {
16661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16662       };
16663     }
16664   }
16665
16666   jresult = (void *)result;
16667   return jresult;
16668 }
16669
16670
16671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
16672   void * jresult ;
16673   Dali::Vector3 *arg1 = 0 ;
16674   Dali::Property::Value *result = 0 ;
16675
16676   arg1 = (Dali::Vector3 *)jarg1;
16677   if (!arg1) {
16678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
16679     return 0;
16680   }
16681   {
16682     try {
16683       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
16684     } catch (std::out_of_range& e) {
16685       {
16686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16687       };
16688     } catch (std::exception& e) {
16689       {
16690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16691       };
16692     } catch (Dali::DaliException e) {
16693       {
16694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16695       };
16696     } catch (...) {
16697       {
16698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16699       };
16700     }
16701   }
16702
16703   jresult = (void *)result;
16704   return jresult;
16705 }
16706
16707
16708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
16709   void * jresult ;
16710   Dali::Vector4 *arg1 = 0 ;
16711   Dali::Property::Value *result = 0 ;
16712
16713   arg1 = (Dali::Vector4 *)jarg1;
16714   if (!arg1) {
16715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
16716     return 0;
16717   }
16718   {
16719     try {
16720       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
16721     } catch (std::out_of_range& e) {
16722       {
16723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16724       };
16725     } catch (std::exception& e) {
16726       {
16727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16728       };
16729     } catch (Dali::DaliException e) {
16730       {
16731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16732       };
16733     } catch (...) {
16734       {
16735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16736       };
16737     }
16738   }
16739
16740   jresult = (void *)result;
16741   return jresult;
16742 }
16743
16744
16745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
16746   void * jresult ;
16747   Dali::Matrix3 *arg1 = 0 ;
16748   Dali::Property::Value *result = 0 ;
16749
16750   arg1 = (Dali::Matrix3 *)jarg1;
16751   if (!arg1) {
16752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
16753     return 0;
16754   }
16755   {
16756     try {
16757       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
16758     } catch (std::out_of_range& e) {
16759       {
16760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16761       };
16762     } catch (std::exception& e) {
16763       {
16764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16765       };
16766     } catch (Dali::DaliException e) {
16767       {
16768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16769       };
16770     } catch (...) {
16771       {
16772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16773       };
16774     }
16775   }
16776
16777   jresult = (void *)result;
16778   return jresult;
16779 }
16780
16781
16782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
16783   void * jresult ;
16784   Dali::Matrix *arg1 = 0 ;
16785   Dali::Property::Value *result = 0 ;
16786
16787   arg1 = (Dali::Matrix *)jarg1;
16788   if (!arg1) {
16789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
16790     return 0;
16791   }
16792   {
16793     try {
16794       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
16795     } catch (std::out_of_range& e) {
16796       {
16797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16798       };
16799     } catch (std::exception& e) {
16800       {
16801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16802       };
16803     } catch (Dali::DaliException e) {
16804       {
16805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16806       };
16807     } catch (...) {
16808       {
16809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16810       };
16811     }
16812   }
16813
16814   jresult = (void *)result;
16815   return jresult;
16816 }
16817
16818
16819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
16820   void * jresult ;
16821   Dali::Rect< int > *arg1 = 0 ;
16822   Dali::Property::Value *result = 0 ;
16823
16824   arg1 = (Dali::Rect< int > *)jarg1;
16825   if (!arg1) {
16826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
16827     return 0;
16828   }
16829   {
16830     try {
16831       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
16832     } catch (std::out_of_range& e) {
16833       {
16834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16835       };
16836     } catch (std::exception& e) {
16837       {
16838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16839       };
16840     } catch (Dali::DaliException e) {
16841       {
16842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16843       };
16844     } catch (...) {
16845       {
16846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16847       };
16848     }
16849   }
16850
16851   jresult = (void *)result;
16852   return jresult;
16853 }
16854
16855
16856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
16857   void * jresult ;
16858   Dali::AngleAxis *arg1 = 0 ;
16859   Dali::Property::Value *result = 0 ;
16860
16861   arg1 = (Dali::AngleAxis *)jarg1;
16862   if (!arg1) {
16863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
16864     return 0;
16865   }
16866   {
16867     try {
16868       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
16869     } catch (std::out_of_range& e) {
16870       {
16871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16872       };
16873     } catch (std::exception& e) {
16874       {
16875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16876       };
16877     } catch (Dali::DaliException e) {
16878       {
16879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16880       };
16881     } catch (...) {
16882       {
16883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16884       };
16885     }
16886   }
16887
16888   jresult = (void *)result;
16889   return jresult;
16890 }
16891
16892
16893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
16894   void * jresult ;
16895   Dali::Quaternion *arg1 = 0 ;
16896   Dali::Property::Value *result = 0 ;
16897
16898   arg1 = (Dali::Quaternion *)jarg1;
16899   if (!arg1) {
16900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
16901     return 0;
16902   }
16903   {
16904     try {
16905       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
16906     } catch (std::out_of_range& e) {
16907       {
16908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16909       };
16910     } catch (std::exception& e) {
16911       {
16912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16913       };
16914     } catch (Dali::DaliException e) {
16915       {
16916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16917       };
16918     } catch (...) {
16919       {
16920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16921       };
16922     }
16923   }
16924
16925   jresult = (void *)result;
16926   return jresult;
16927 }
16928
16929
16930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
16931   void * jresult ;
16932   std::string *arg1 = 0 ;
16933   Dali::Property::Value *result = 0 ;
16934
16935   if (!jarg1) {
16936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16937     return 0;
16938   }
16939   std::string arg1_str(jarg1);
16940   arg1 = &arg1_str;
16941   {
16942     try {
16943       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
16944     } catch (std::out_of_range& e) {
16945       {
16946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16947       };
16948     } catch (std::exception& e) {
16949       {
16950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16951       };
16952     } catch (Dali::DaliException e) {
16953       {
16954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16955       };
16956     } catch (...) {
16957       {
16958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16959       };
16960     }
16961   }
16962
16963   jresult = (void *)result;
16964
16965   //argout typemap for const std::string&
16966
16967   return jresult;
16968 }
16969
16970
16971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
16972   void * jresult ;
16973   Dali::Property::Array *arg1 = 0 ;
16974   Dali::Property::Value *result = 0 ;
16975
16976   arg1 = (Dali::Property::Array *)jarg1;
16977   if (!arg1) {
16978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
16979     return 0;
16980   }
16981   {
16982     try {
16983       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
16984     } catch (std::out_of_range& e) {
16985       {
16986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16987       };
16988     } catch (std::exception& e) {
16989       {
16990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16991       };
16992     } catch (Dali::DaliException e) {
16993       {
16994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16995       };
16996     } catch (...) {
16997       {
16998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16999       };
17000     }
17001   }
17002
17003   jresult = (void *)result;
17004   return jresult;
17005 }
17006
17007
17008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
17009   void * jresult ;
17010   Dali::Property::Map *arg1 = 0 ;
17011   Dali::Property::Value *result = 0 ;
17012
17013   arg1 = (Dali::Property::Map *)jarg1;
17014   if (!arg1) {
17015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17016     return 0;
17017   }
17018   {
17019     try {
17020       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17021     } catch (std::out_of_range& e) {
17022       {
17023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17024       };
17025     } catch (std::exception& e) {
17026       {
17027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17028       };
17029     } catch (Dali::DaliException e) {
17030       {
17031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17032       };
17033     } catch (...) {
17034       {
17035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17036       };
17037     }
17038   }
17039
17040   jresult = (void *)result;
17041   return jresult;
17042 }
17043
17044
17045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
17046   void * jresult ;
17047   Extents *arg1 = 0 ;
17048   Dali::Property::Value *result = 0 ;
17049
17050   arg1 = (Extents *)jarg1;
17051   if (!arg1) {
17052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
17053     return 0;
17054   }
17055   {
17056     try {
17057       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
17058     } catch (std::out_of_range& e) {
17059       {
17060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17061       };
17062     } catch (std::exception& e) {
17063       {
17064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17065       };
17066     } catch (...) {
17067       {
17068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17069       };
17070     }
17071   }
17072   jresult = (void *)result;
17073   return jresult;
17074 }
17075
17076
17077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
17078   void * jresult ;
17079   Dali::Property::Type arg1 ;
17080   Dali::Property::Value *result = 0 ;
17081
17082   arg1 = (Dali::Property::Type)jarg1;
17083   {
17084     try {
17085       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
17086     } catch (std::out_of_range& e) {
17087       {
17088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17089       };
17090     } catch (std::exception& e) {
17091       {
17092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17093       };
17094     } catch (Dali::DaliException e) {
17095       {
17096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17097       };
17098     } catch (...) {
17099       {
17100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17101       };
17102     }
17103   }
17104
17105   jresult = (void *)result;
17106   return jresult;
17107 }
17108
17109
17110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
17111   void * jresult ;
17112   Dali::Property::Value *arg1 = 0 ;
17113   Dali::Property::Value *result = 0 ;
17114
17115   arg1 = (Dali::Property::Value *)jarg1;
17116   if (!arg1) {
17117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17118     return 0;
17119   }
17120   {
17121     try {
17122       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
17123     } catch (std::out_of_range& e) {
17124       {
17125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17126       };
17127     } catch (std::exception& e) {
17128       {
17129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17130       };
17131     } catch (Dali::DaliException e) {
17132       {
17133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17134       };
17135     } catch (...) {
17136       {
17137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17138       };
17139     }
17140   }
17141
17142   jresult = (void *)result;
17143   return jresult;
17144 }
17145
17146
17147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
17148   void * jresult ;
17149   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17150   Dali::Property::Value *arg2 = 0 ;
17151   Dali::Property::Value *result = 0 ;
17152
17153   arg1 = (Dali::Property::Value *)jarg1;
17154   arg2 = (Dali::Property::Value *)jarg2;
17155   if (!arg2) {
17156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17157     return 0;
17158   }
17159   {
17160     try {
17161       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
17162     } catch (std::out_of_range& e) {
17163       {
17164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17165       };
17166     } catch (std::exception& e) {
17167       {
17168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17169       };
17170     } catch (Dali::DaliException e) {
17171       {
17172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17173       };
17174     } catch (...) {
17175       {
17176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17177       };
17178     }
17179   }
17180
17181   jresult = (void *)result;
17182   return jresult;
17183 }
17184
17185
17186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
17187   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17188
17189   arg1 = (Dali::Property::Value *)jarg1;
17190   {
17191     try {
17192       delete arg1;
17193     } catch (std::out_of_range& e) {
17194       {
17195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17196       };
17197     } catch (std::exception& e) {
17198       {
17199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17200       };
17201     } catch (Dali::DaliException e) {
17202       {
17203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
17204       };
17205     } catch (...) {
17206       {
17207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17208       };
17209     }
17210   }
17211
17212 }
17213
17214
17215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
17216   int jresult ;
17217   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17218   Dali::Property::Type result;
17219
17220   arg1 = (Dali::Property::Value *)jarg1;
17221   {
17222     try {
17223       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
17224     } catch (std::out_of_range& e) {
17225       {
17226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17227       };
17228     } catch (std::exception& e) {
17229       {
17230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17231       };
17232     } catch (Dali::DaliException e) {
17233       {
17234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17235       };
17236     } catch (...) {
17237       {
17238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17239       };
17240     }
17241   }
17242
17243   jresult = (int)result;
17244   return jresult;
17245 }
17246
17247
17248 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
17249   unsigned int jresult ;
17250   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17251   bool *arg2 = 0 ;
17252   bool result;
17253
17254   arg1 = (Dali::Property::Value *)jarg1;
17255   arg2 = (bool *)jarg2;
17256   {
17257     try {
17258       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17259     } catch (std::out_of_range& e) {
17260       {
17261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17262       };
17263     } catch (std::exception& e) {
17264       {
17265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17266       };
17267     } catch (Dali::DaliException e) {
17268       {
17269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17270       };
17271     } catch (...) {
17272       {
17273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17274       };
17275     }
17276   }
17277
17278   jresult = result;
17279   return jresult;
17280 }
17281
17282
17283 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
17284   unsigned int jresult ;
17285   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17286   float *arg2 = 0 ;
17287   bool result;
17288
17289   arg1 = (Dali::Property::Value *)jarg1;
17290   arg2 = (float *)jarg2;
17291   {
17292     try {
17293       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17294     } catch (std::out_of_range& e) {
17295       {
17296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17297       };
17298     } catch (std::exception& e) {
17299       {
17300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17301       };
17302     } catch (Dali::DaliException e) {
17303       {
17304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17305       };
17306     } catch (...) {
17307       {
17308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17309       };
17310     }
17311   }
17312
17313   jresult = result;
17314   return jresult;
17315 }
17316
17317
17318 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
17319   unsigned int jresult ;
17320   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17321   int *arg2 = 0 ;
17322   bool result;
17323
17324   arg1 = (Dali::Property::Value *)jarg1;
17325   arg2 = (int *)jarg2;
17326   {
17327     try {
17328       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17329     } catch (std::out_of_range& e) {
17330       {
17331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17332       };
17333     } catch (std::exception& e) {
17334       {
17335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17336       };
17337     } catch (Dali::DaliException e) {
17338       {
17339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17340       };
17341     } catch (...) {
17342       {
17343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17344       };
17345     }
17346   }
17347
17348   jresult = result;
17349   return jresult;
17350 }
17351
17352
17353 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
17354   unsigned int jresult ;
17355   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17356   Dali::Rect< int > *arg2 = 0 ;
17357   bool result;
17358
17359   arg1 = (Dali::Property::Value *)jarg1;
17360   arg2 = (Dali::Rect< int > *)jarg2;
17361   if (!arg2) {
17362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
17363     return 0;
17364   }
17365   {
17366     try {
17367       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17368     } catch (std::out_of_range& e) {
17369       {
17370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17371       };
17372     } catch (std::exception& e) {
17373       {
17374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17375       };
17376     } catch (Dali::DaliException e) {
17377       {
17378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17379       };
17380     } catch (...) {
17381       {
17382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17383       };
17384     }
17385   }
17386
17387   jresult = result;
17388   return jresult;
17389 }
17390
17391
17392 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
17393   unsigned int jresult ;
17394   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17395   Dali::Vector2 *arg2 = 0 ;
17396   bool result;
17397
17398   arg1 = (Dali::Property::Value *)jarg1;
17399   arg2 = (Dali::Vector2 *)jarg2;
17400   if (!arg2) {
17401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
17402     return 0;
17403   }
17404   {
17405     try {
17406       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17407     } catch (std::out_of_range& e) {
17408       {
17409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17410       };
17411     } catch (std::exception& e) {
17412       {
17413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17414       };
17415     } catch (Dali::DaliException e) {
17416       {
17417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17418       };
17419     } catch (...) {
17420       {
17421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17422       };
17423     }
17424   }
17425
17426   jresult = result;
17427   return jresult;
17428 }
17429
17430
17431 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
17432   unsigned int jresult ;
17433   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17434   Dali::Vector3 *arg2 = 0 ;
17435   bool result;
17436
17437   arg1 = (Dali::Property::Value *)jarg1;
17438   arg2 = (Dali::Vector3 *)jarg2;
17439   if (!arg2) {
17440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
17441     return 0;
17442   }
17443   {
17444     try {
17445       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17446     } catch (std::out_of_range& e) {
17447       {
17448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17449       };
17450     } catch (std::exception& e) {
17451       {
17452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17453       };
17454     } catch (Dali::DaliException e) {
17455       {
17456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17457       };
17458     } catch (...) {
17459       {
17460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17461       };
17462     }
17463   }
17464
17465   jresult = result;
17466   return jresult;
17467 }
17468
17469
17470 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
17471   unsigned int jresult ;
17472   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17473   Dali::Vector4 *arg2 = 0 ;
17474   bool result;
17475
17476   arg1 = (Dali::Property::Value *)jarg1;
17477   arg2 = (Dali::Vector4 *)jarg2;
17478   if (!arg2) {
17479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
17480     return 0;
17481   }
17482   {
17483     try {
17484       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17485     } catch (std::out_of_range& e) {
17486       {
17487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17488       };
17489     } catch (std::exception& e) {
17490       {
17491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17492       };
17493     } catch (Dali::DaliException e) {
17494       {
17495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17496       };
17497     } catch (...) {
17498       {
17499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17500       };
17501     }
17502   }
17503
17504   jresult = result;
17505   return jresult;
17506 }
17507
17508
17509 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
17510   unsigned int jresult ;
17511   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17512   Dali::Matrix3 *arg2 = 0 ;
17513   bool result;
17514
17515   arg1 = (Dali::Property::Value *)jarg1;
17516   arg2 = (Dali::Matrix3 *)jarg2;
17517   if (!arg2) {
17518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
17519     return 0;
17520   }
17521   {
17522     try {
17523       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17524     } catch (std::out_of_range& e) {
17525       {
17526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17527       };
17528     } catch (std::exception& e) {
17529       {
17530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17531       };
17532     } catch (Dali::DaliException e) {
17533       {
17534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17535       };
17536     } catch (...) {
17537       {
17538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17539       };
17540     }
17541   }
17542
17543   jresult = result;
17544   return jresult;
17545 }
17546
17547
17548 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
17549   unsigned int jresult ;
17550   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17551   Dali::Matrix *arg2 = 0 ;
17552   bool result;
17553
17554   arg1 = (Dali::Property::Value *)jarg1;
17555   arg2 = (Dali::Matrix *)jarg2;
17556   if (!arg2) {
17557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
17558     return 0;
17559   }
17560   {
17561     try {
17562       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17563     } catch (std::out_of_range& e) {
17564       {
17565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17566       };
17567     } catch (std::exception& e) {
17568       {
17569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17570       };
17571     } catch (Dali::DaliException e) {
17572       {
17573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17574       };
17575     } catch (...) {
17576       {
17577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17578       };
17579     }
17580   }
17581
17582   jresult = result;
17583   return jresult;
17584 }
17585
17586
17587 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
17588   unsigned int jresult ;
17589   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17590   Dali::AngleAxis *arg2 = 0 ;
17591   bool result;
17592
17593   arg1 = (Dali::Property::Value *)jarg1;
17594   arg2 = (Dali::AngleAxis *)jarg2;
17595   if (!arg2) {
17596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
17597     return 0;
17598   }
17599   {
17600     try {
17601       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17602     } catch (std::out_of_range& e) {
17603       {
17604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17605       };
17606     } catch (std::exception& e) {
17607       {
17608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17609       };
17610     } catch (Dali::DaliException e) {
17611       {
17612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17613       };
17614     } catch (...) {
17615       {
17616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17617       };
17618     }
17619   }
17620
17621   jresult = result;
17622   return jresult;
17623 }
17624
17625
17626 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
17627   unsigned int jresult ;
17628   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17629   Dali::Quaternion *arg2 = 0 ;
17630   bool result;
17631
17632   arg1 = (Dali::Property::Value *)jarg1;
17633   arg2 = (Dali::Quaternion *)jarg2;
17634   if (!arg2) {
17635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
17636     return 0;
17637   }
17638   {
17639     try {
17640       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17641     } catch (std::out_of_range& e) {
17642       {
17643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17644       };
17645     } catch (std::exception& e) {
17646       {
17647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17648       };
17649     } catch (Dali::DaliException e) {
17650       {
17651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17652       };
17653     } catch (...) {
17654       {
17655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17656       };
17657     }
17658   }
17659
17660   jresult = result;
17661   return jresult;
17662 }
17663
17664
17665 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
17666   unsigned int jresult ;
17667   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17668   std::string *arg2 = 0 ;
17669   bool result;
17670
17671   arg1 = (Dali::Property::Value *)jarg1;
17672
17673   //typemap in
17674   std::string temp;
17675   arg2 = &temp;
17676
17677   {
17678     try {
17679       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17680     } catch (std::out_of_range& e) {
17681       {
17682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17683       };
17684     } catch (std::exception& e) {
17685       {
17686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17687       };
17688     } catch (Dali::DaliException e) {
17689       {
17690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17691       };
17692     } catch (...) {
17693       {
17694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17695       };
17696     }
17697   }
17698
17699   jresult = result;
17700
17701   //Typemap argout in c++ file.
17702   //This will convert c++ string to c# string
17703   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
17704
17705   return jresult;
17706 }
17707
17708
17709 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
17710   unsigned int jresult ;
17711   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17712   Dali::Property::Array *arg2 = 0 ;
17713   bool result;
17714
17715   arg1 = (Dali::Property::Value *)jarg1;
17716   arg2 = (Dali::Property::Array *)jarg2;
17717   if (!arg2) {
17718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17719     return 0;
17720   }
17721   {
17722     try {
17723       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17724     } catch (std::out_of_range& e) {
17725       {
17726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17727       };
17728     } catch (std::exception& e) {
17729       {
17730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17731       };
17732     } catch (Dali::DaliException e) {
17733       {
17734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17735       };
17736     } catch (...) {
17737       {
17738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17739       };
17740     }
17741   }
17742
17743   jresult = result;
17744   return jresult;
17745 }
17746
17747
17748 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
17749   unsigned int jresult ;
17750   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17751   Dali::Property::Map *arg2 = 0 ;
17752   bool result;
17753
17754   arg1 = (Dali::Property::Value *)jarg1;
17755   arg2 = (Dali::Property::Map *)jarg2;
17756   if (!arg2) {
17757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17758     return 0;
17759   }
17760   {
17761     try {
17762       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17763     } catch (std::out_of_range& e) {
17764       {
17765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17766       };
17767     } catch (std::exception& e) {
17768       {
17769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17770       };
17771     } catch (Dali::DaliException e) {
17772       {
17773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17774       };
17775     } catch (...) {
17776       {
17777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17778       };
17779     }
17780   }
17781
17782   jresult = result;
17783   return jresult;
17784 }
17785
17786
17787 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
17788   unsigned int jresult ;
17789   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17790   Extents *arg2 = 0 ;
17791   bool result;
17792
17793   arg1 = (Dali::Property::Value *)jarg1;
17794   arg2 = (Extents *)jarg2;
17795   if (!arg2) {
17796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
17797     return 0;
17798   }
17799   {
17800     try {
17801       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17802     } catch (std::out_of_range& e) {
17803       {
17804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17805       };
17806     } catch (std::exception& e) {
17807       {
17808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17809       };
17810     } catch (...) {
17811       {
17812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17813       };
17814     }
17815   }
17816   jresult = result;
17817   return jresult;
17818 }
17819
17820
17821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
17822   void * jresult ;
17823   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17824   Dali::Property::Array *result = 0 ;
17825
17826   arg1 = (Dali::Property::Value *)jarg1;
17827   {
17828     try {
17829       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
17830     } catch (std::out_of_range& e) {
17831       {
17832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17833       };
17834     } catch (std::exception& e) {
17835       {
17836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17837       };
17838     } catch (Dali::DaliException e) {
17839       {
17840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17841       };
17842     } catch (...) {
17843       {
17844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17845       };
17846     }
17847   }
17848
17849   jresult = (void *)result;
17850   return jresult;
17851 }
17852
17853
17854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
17855   void * jresult ;
17856   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17857   Dali::Property::Map *result = 0 ;
17858
17859   arg1 = (Dali::Property::Value *)jarg1;
17860   {
17861     try {
17862       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
17863     } catch (std::out_of_range& e) {
17864       {
17865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17866       };
17867     } catch (std::exception& e) {
17868       {
17869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17870       };
17871     } catch (Dali::DaliException e) {
17872       {
17873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17874       };
17875     } catch (...) {
17876       {
17877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17878       };
17879     }
17880   }
17881
17882   jresult = (void *)result;
17883   return jresult;
17884 }
17885
17886
17887 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
17888   char * jresult ;
17889   Dali::Property::Type arg1 ;
17890   char *result = 0 ;
17891
17892   arg1 = (Dali::Property::Type)jarg1;
17893   {
17894     try {
17895       result = (char *)Dali::PropertyTypes::GetName(arg1);
17896     } catch (std::out_of_range& e) {
17897       {
17898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17899       };
17900     } catch (std::exception& e) {
17901       {
17902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17903       };
17904     } catch (Dali::DaliException e) {
17905       {
17906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17907       };
17908     } catch (...) {
17909       {
17910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17911       };
17912     }
17913   }
17914
17915   jresult = SWIG_csharp_string_callback((const char *)result);
17916   return jresult;
17917 }
17918
17919
17920 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
17921   unsigned int jresult ;
17922   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
17923   std::string *arg2 = 0 ;
17924   Dali::Property::Map *arg3 = 0 ;
17925   bool result;
17926
17927   arg1 = (Dali::BaseObject *)jarg1;
17928   if (!jarg2) {
17929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17930     return 0;
17931   }
17932   std::string arg2_str(jarg2);
17933   arg2 = &arg2_str;
17934   arg3 = (Dali::Property::Map *)jarg3;
17935   if (!arg3) {
17936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
17937     return 0;
17938   }
17939   {
17940     try {
17941       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
17942     } catch (std::out_of_range& e) {
17943       {
17944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17945       };
17946     } catch (std::exception& e) {
17947       {
17948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17949       };
17950     } catch (Dali::DaliException e) {
17951       {
17952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17953       };
17954     } catch (...) {
17955       {
17956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17957       };
17958     }
17959   }
17960
17961   jresult = result;
17962
17963   //argout typemap for const std::string&
17964
17965   return jresult;
17966 }
17967
17968
17969 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
17970   char * jresult ;
17971   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
17972   std::string *result = 0 ;
17973
17974   arg1 = (Dali::BaseObject *)jarg1;
17975   {
17976     try {
17977       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
17978     } catch (std::out_of_range& e) {
17979       {
17980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17981       };
17982     } catch (std::exception& e) {
17983       {
17984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17985       };
17986     } catch (Dali::DaliException e) {
17987       {
17988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17989       };
17990     } catch (...) {
17991       {
17992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17993       };
17994     }
17995   }
17996
17997   jresult = SWIG_csharp_string_callback(result->c_str());
17998   return jresult;
17999 }
18000
18001
18002 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
18003   unsigned int jresult ;
18004   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18005   Dali::TypeInfo *arg2 = 0 ;
18006   bool result;
18007
18008   arg1 = (Dali::BaseObject *)jarg1;
18009   arg2 = (Dali::TypeInfo *)jarg2;
18010   if (!arg2) {
18011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18012     return 0;
18013   }
18014   {
18015     try {
18016       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
18017     } catch (std::out_of_range& e) {
18018       {
18019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18020       };
18021     } catch (std::exception& e) {
18022       {
18023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18024       };
18025     } catch (Dali::DaliException e) {
18026       {
18027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18028       };
18029     } catch (...) {
18030       {
18031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18032       };
18033     }
18034   }
18035
18036   jresult = result;
18037   return jresult;
18038 }
18039
18040
18041 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
18042   unsigned int jresult ;
18043   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18044   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
18045   std::string *arg3 = 0 ;
18046   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
18047   bool result;
18048
18049   arg1 = (Dali::BaseObject *)jarg1;
18050   arg2 = (ConnectionTrackerInterface *)jarg2;
18051   if (!jarg3) {
18052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18053     return 0;
18054   }
18055   std::string arg3_str(jarg3);
18056   arg3 = &arg3_str;
18057   arg4 = (FunctorDelegate *)jarg4;
18058   {
18059     try {
18060       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
18061     } catch (std::out_of_range& e) {
18062       {
18063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18064       };
18065     } catch (std::exception& e) {
18066       {
18067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18068       };
18069     } catch (Dali::DaliException e) {
18070       {
18071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18072       };
18073     } catch (...) {
18074       {
18075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18076       };
18077     }
18078   }
18079
18080   jresult = result;
18081
18082   //argout typemap for const std::string&
18083
18084   return jresult;
18085 }
18086
18087
18088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
18089   void * jresult ;
18090   Dali::BaseHandle *arg1 = 0 ;
18091   Dali::BaseObject *result = 0 ;
18092
18093   arg1 = (Dali::BaseHandle *)jarg1;
18094   if (!arg1) {
18095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18096     return 0;
18097   }
18098   {
18099     try {
18100       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
18101     } catch (std::out_of_range& e) {
18102       {
18103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18104       };
18105     } catch (std::exception& e) {
18106       {
18107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18108       };
18109     } catch (Dali::DaliException e) {
18110       {
18111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18112       };
18113     } catch (...) {
18114       {
18115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18116       };
18117     }
18118   }
18119
18120   jresult = (void *)result;
18121   return jresult;
18122 }
18123
18124
18125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
18126   void * jresult ;
18127   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18128   Dali::BaseHandle *result = 0 ;
18129
18130   arg1 = (Dali::BaseObject *)jarg1;
18131   {
18132     try {
18133       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
18134     } catch (std::out_of_range& e) {
18135       {
18136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18137       };
18138     } catch (std::exception& e) {
18139       {
18140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18141       };
18142     } catch (Dali::DaliException e) {
18143       {
18144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18145       };
18146     } catch (...) {
18147       {
18148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18149       };
18150     }
18151   }
18152
18153   jresult = (void *)result;
18154   return jresult;
18155 }
18156
18157
18158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
18159   void * jresult ;
18160   Dali::BaseHandle *result = 0 ;
18161
18162   {
18163     try {
18164       result = (Dali::BaseHandle *)new Dali::BaseHandle();
18165     } catch (std::out_of_range& e) {
18166       {
18167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18168       };
18169     } catch (std::exception& e) {
18170       {
18171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18172       };
18173     } catch (Dali::DaliException e) {
18174       {
18175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18176       };
18177     } catch (...) {
18178       {
18179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18180       };
18181     }
18182   }
18183
18184   jresult = (void *)result;
18185   return jresult;
18186 }
18187
18188
18189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
18190   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18191
18192   arg1 = (Dali::BaseHandle *)jarg1;
18193   {
18194     try {
18195       delete arg1;
18196     } catch (std::out_of_range& e) {
18197       {
18198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18199       };
18200     } catch (std::exception& e) {
18201       {
18202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18203       };
18204     } catch (Dali::DaliException e) {
18205       {
18206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18207       };
18208     } catch (...) {
18209       {
18210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18211       };
18212     }
18213   }
18214
18215 }
18216
18217
18218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
18219   void * jresult ;
18220   Dali::BaseHandle *arg1 = 0 ;
18221   Dali::BaseHandle *result = 0 ;
18222
18223   arg1 = (Dali::BaseHandle *)jarg1;
18224   if (!arg1) {
18225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18226     return 0;
18227   }
18228   {
18229     try {
18230       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
18231     } catch (std::out_of_range& e) {
18232       {
18233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18234       };
18235     } catch (std::exception& e) {
18236       {
18237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18238       };
18239     } catch (Dali::DaliException e) {
18240       {
18241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18242       };
18243     } catch (...) {
18244       {
18245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18246       };
18247     }
18248   }
18249
18250   jresult = (void *)result;
18251   return jresult;
18252 }
18253
18254
18255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
18256   void * jresult ;
18257   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18258   Dali::BaseHandle *arg2 = 0 ;
18259   Dali::BaseHandle *result = 0 ;
18260
18261   arg1 = (Dali::BaseHandle *)jarg1;
18262   arg2 = (Dali::BaseHandle *)jarg2;
18263   if (!arg2) {
18264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18265     return 0;
18266   }
18267   {
18268     try {
18269       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
18270     } catch (std::out_of_range& e) {
18271       {
18272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18273       };
18274     } catch (std::exception& e) {
18275       {
18276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18277       };
18278     } catch (Dali::DaliException e) {
18279       {
18280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18281       };
18282     } catch (...) {
18283       {
18284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18285       };
18286     }
18287   }
18288
18289   jresult = (void *)result;
18290   return jresult;
18291 }
18292
18293
18294 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18295   unsigned int jresult ;
18296   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18297   std::string *arg2 = 0 ;
18298   Dali::Property::Map *arg3 = 0 ;
18299   bool result;
18300
18301   arg1 = (Dali::BaseHandle *)jarg1;
18302   if (!jarg2) {
18303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18304     return 0;
18305   }
18306   std::string arg2_str(jarg2);
18307   arg2 = &arg2_str;
18308   arg3 = (Dali::Property::Map *)jarg3;
18309   if (!arg3) {
18310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18311     return 0;
18312   }
18313   {
18314     try {
18315       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18316     } catch (std::out_of_range& e) {
18317       {
18318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18319       };
18320     } catch (std::exception& e) {
18321       {
18322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18323       };
18324     } catch (Dali::DaliException e) {
18325       {
18326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18327       };
18328     } catch (...) {
18329       {
18330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18331       };
18332     }
18333   }
18334
18335   jresult = result;
18336
18337   //argout typemap for const std::string&
18338
18339   return jresult;
18340 }
18341
18342
18343 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
18344   char * jresult ;
18345   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18346   std::string *result = 0 ;
18347
18348   arg1 = (Dali::BaseHandle *)jarg1;
18349   {
18350     try {
18351       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
18352     } catch (std::out_of_range& e) {
18353       {
18354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18355       };
18356     } catch (std::exception& e) {
18357       {
18358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18359       };
18360     } catch (Dali::DaliException e) {
18361       {
18362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18363       };
18364     } catch (...) {
18365       {
18366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18367       };
18368     }
18369   }
18370
18371   jresult = SWIG_csharp_string_callback(result->c_str());
18372   return jresult;
18373 }
18374
18375
18376 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
18377   unsigned int jresult ;
18378   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18379   Dali::TypeInfo *arg2 = 0 ;
18380   bool result;
18381
18382   arg1 = (Dali::BaseHandle *)jarg1;
18383   arg2 = (Dali::TypeInfo *)jarg2;
18384   if (!arg2) {
18385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18386     return 0;
18387   }
18388   {
18389     try {
18390       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
18391     } catch (std::out_of_range& e) {
18392       {
18393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18394       };
18395     } catch (std::exception& e) {
18396       {
18397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18398       };
18399     } catch (Dali::DaliException e) {
18400       {
18401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18402       };
18403     } catch (...) {
18404       {
18405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18406       };
18407     }
18408   }
18409
18410   jresult = result;
18411   return jresult;
18412 }
18413
18414
18415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
18416   void * jresult ;
18417   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18418   Dali::BaseObject *result = 0 ;
18419
18420   arg1 = (Dali::BaseHandle *)jarg1;
18421   {
18422     try {
18423       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
18424     } catch (std::out_of_range& e) {
18425       {
18426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18427       };
18428     } catch (std::exception& e) {
18429       {
18430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18431       };
18432     } catch (Dali::DaliException e) {
18433       {
18434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18435       };
18436     } catch (...) {
18437       {
18438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18439       };
18440     }
18441   }
18442
18443   jresult = (void *)result;
18444   return jresult;
18445 }
18446
18447
18448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
18449   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18450
18451   arg1 = (Dali::BaseHandle *)jarg1;
18452   {
18453     try {
18454       (arg1)->Reset();
18455     } catch (std::out_of_range& e) {
18456       {
18457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18458       };
18459     } catch (std::exception& e) {
18460       {
18461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18462       };
18463     } catch (Dali::DaliException e) {
18464       {
18465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18466       };
18467     } catch (...) {
18468       {
18469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18470       };
18471     }
18472   }
18473
18474 }
18475
18476
18477 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
18478   unsigned int jresult ;
18479   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18480   Dali::BaseHandle *arg2 = 0 ;
18481   bool result;
18482
18483   arg1 = (Dali::BaseHandle *)jarg1;
18484   arg2 = (Dali::BaseHandle *)jarg2;
18485   if (!arg2) {
18486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18487     return 0;
18488   }
18489   {
18490     try {
18491       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
18492     } catch (std::out_of_range& e) {
18493       {
18494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18495       };
18496     } catch (std::exception& e) {
18497       {
18498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18499       };
18500     } catch (Dali::DaliException e) {
18501       {
18502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18503       };
18504     } catch (...) {
18505       {
18506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18507       };
18508     }
18509   }
18510
18511   jresult = result;
18512   return jresult;
18513 }
18514
18515
18516 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
18517   unsigned int jresult ;
18518   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18519   Dali::BaseHandle *arg2 = 0 ;
18520   bool result;
18521
18522   arg1 = (Dali::BaseHandle *)jarg1;
18523   arg2 = (Dali::BaseHandle *)jarg2;
18524   if (!arg2) {
18525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18526     return 0;
18527   }
18528   {
18529     try {
18530       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
18531     } catch (std::out_of_range& e) {
18532       {
18533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18534       };
18535     } catch (std::exception& e) {
18536       {
18537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18538       };
18539     } catch (Dali::DaliException e) {
18540       {
18541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18542       };
18543     } catch (...) {
18544       {
18545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18546       };
18547     }
18548   }
18549
18550   jresult = result;
18551   return jresult;
18552 }
18553
18554
18555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
18556   void * jresult ;
18557   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18558   Dali::RefObject *result = 0 ;
18559
18560   arg1 = (Dali::BaseHandle *)jarg1;
18561   {
18562     try {
18563       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
18564     } catch (std::out_of_range& e) {
18565       {
18566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18567       };
18568     } catch (std::exception& e) {
18569       {
18570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18571       };
18572     } catch (Dali::DaliException e) {
18573       {
18574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18575       };
18576     } catch (...) {
18577       {
18578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18579       };
18580     }
18581   }
18582
18583   jresult = (void *)result;
18584   return jresult;
18585 }
18586
18587
18588 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
18589   unsigned int jresult ;
18590   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18591   bool result;
18592
18593   arg1 = (Dali::BaseHandle *)jarg1;
18594   {
18595     try {
18596       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
18597     } catch (std::out_of_range& e) {
18598       {
18599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18600       };
18601     } catch (std::exception& e) {
18602       {
18603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18604       };
18605     } catch (Dali::DaliException e) {
18606       {
18607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18608       };
18609     } catch (...) {
18610       {
18611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18612       };
18613     }
18614   }
18615
18616   jresult = result;
18617   return jresult;
18618 }
18619
18620
18621 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
18622   unsigned int jresult ;
18623   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18624   Dali::BaseHandle *arg2 = 0 ;
18625   bool result;
18626
18627   arg1 = (Dali::BaseHandle *)jarg1;
18628   arg2 = (Dali::BaseHandle *)jarg2;
18629   if (!arg2) {
18630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18631     return 0;
18632   }
18633   {
18634     try {
18635       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
18636     } catch (std::out_of_range& e) {
18637       {
18638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18639       };
18640     } catch (std::exception& e) {
18641       {
18642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18643       };
18644     } catch (Dali::DaliException e) {
18645       {
18646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18647       };
18648     } catch (...) {
18649       {
18650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18651       };
18652     }
18653   }
18654
18655   jresult = result;
18656   return jresult;
18657 }
18658
18659
18660 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
18661   unsigned int jresult ;
18662   Dali::BaseHandle *arg1 = 0 ;
18663   Dali::BaseHandle *arg2 = 0 ;
18664   bool result;
18665
18666   arg1 = (Dali::BaseHandle *)jarg1;
18667   if (!arg1) {
18668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18669     return 0;
18670   }
18671   arg2 = (Dali::BaseHandle *)jarg2;
18672   if (!arg2) {
18673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18674     return 0;
18675   }
18676   {
18677     try {
18678       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
18679     } catch (std::out_of_range& e) {
18680       {
18681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18682       };
18683     } catch (std::exception& e) {
18684       {
18685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18686       };
18687     } catch (Dali::DaliException e) {
18688       {
18689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18690       };
18691     } catch (...) {
18692       {
18693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18694       };
18695     }
18696   }
18697
18698   jresult = result;
18699   return jresult;
18700 }
18701
18702
18703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
18704   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18705
18706   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18707   {
18708     try {
18709       delete arg1;
18710     } catch (std::out_of_range& e) {
18711       {
18712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18713       };
18714     } catch (std::exception& e) {
18715       {
18716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18717       };
18718     } catch (Dali::DaliException e) {
18719       {
18720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18721       };
18722     } catch (...) {
18723       {
18724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18725       };
18726     }
18727   }
18728
18729 }
18730
18731
18732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
18733   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18734   SlotObserver *arg2 = (SlotObserver *) 0 ;
18735   CallbackBase *arg3 = (CallbackBase *) 0 ;
18736
18737   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18738   arg2 = (SlotObserver *)jarg2;
18739   arg3 = (CallbackBase *)jarg3;
18740   {
18741     try {
18742       (arg1)->SignalConnected(arg2,arg3);
18743     } catch (std::out_of_range& e) {
18744       {
18745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18746       };
18747     } catch (std::exception& e) {
18748       {
18749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18750       };
18751     } catch (Dali::DaliException e) {
18752       {
18753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18754       };
18755     } catch (...) {
18756       {
18757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18758       };
18759     }
18760   }
18761
18762 }
18763
18764
18765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
18766   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18767
18768   arg1 = (Dali::SignalObserver *)jarg1;
18769   {
18770     try {
18771       delete arg1;
18772     } catch (std::out_of_range& e) {
18773       {
18774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18775       };
18776     } catch (std::exception& e) {
18777       {
18778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18779       };
18780     } catch (Dali::DaliException e) {
18781       {
18782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18783       };
18784     } catch (...) {
18785       {
18786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18787       };
18788     }
18789   }
18790
18791 }
18792
18793
18794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
18795   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18796   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
18797   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
18798
18799   arg1 = (Dali::SignalObserver *)jarg1;
18800   arg2 = (Dali::SlotObserver *)jarg2;
18801   arg3 = (Dali::CallbackBase *)jarg3;
18802   {
18803     try {
18804       (arg1)->SignalDisconnected(arg2,arg3);
18805     } catch (std::out_of_range& e) {
18806       {
18807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18808       };
18809     } catch (std::exception& e) {
18810       {
18811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18812       };
18813     } catch (Dali::DaliException e) {
18814       {
18815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18816       };
18817     } catch (...) {
18818       {
18819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18820       };
18821     }
18822   }
18823
18824 }
18825
18826
18827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
18828   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18829
18830   arg1 = (Dali::SlotObserver *)jarg1;
18831   {
18832     try {
18833       delete arg1;
18834     } catch (std::out_of_range& e) {
18835       {
18836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18837       };
18838     } catch (std::exception& e) {
18839       {
18840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18841       };
18842     } catch (Dali::DaliException e) {
18843       {
18844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18845       };
18846     } catch (...) {
18847       {
18848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18849       };
18850     }
18851   }
18852
18853 }
18854
18855
18856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
18857   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18858   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
18859
18860   arg1 = (Dali::SlotObserver *)jarg1;
18861   arg2 = (Dali::CallbackBase *)jarg2;
18862   {
18863     try {
18864       (arg1)->SlotDisconnected(arg2);
18865     } catch (std::out_of_range& e) {
18866       {
18867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18868       };
18869     } catch (std::exception& e) {
18870       {
18871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18872       };
18873     } catch (Dali::DaliException e) {
18874       {
18875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18876       };
18877     } catch (...) {
18878       {
18879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18880       };
18881     }
18882   }
18883
18884 }
18885
18886
18887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
18888   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
18889
18890   arg1 = (Dali::ConnectionTracker *)jarg1;
18891   {
18892     try {
18893       delete arg1;
18894     } catch (std::out_of_range& e) {
18895       {
18896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18897       };
18898     } catch (std::exception& e) {
18899       {
18900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18901       };
18902     } catch (Dali::DaliException e) {
18903       {
18904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18905       };
18906     } catch (...) {
18907       {
18908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18909       };
18910     }
18911   }
18912
18913 }
18914
18915
18916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
18917   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
18918
18919   arg1 = (Dali::ConnectionTracker *)jarg1;
18920   {
18921     try {
18922       (arg1)->DisconnectAll();
18923     } catch (std::out_of_range& e) {
18924       {
18925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18926       };
18927     } catch (std::exception& e) {
18928       {
18929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18930       };
18931     } catch (Dali::DaliException e) {
18932       {
18933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18934       };
18935     } catch (...) {
18936       {
18937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18938       };
18939     }
18940   }
18941
18942 }
18943
18944
18945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
18946   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
18947   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
18948   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
18949
18950   arg1 = (Dali::ConnectionTracker *)jarg1;
18951   arg2 = (Dali::SlotObserver *)jarg2;
18952   arg3 = (Dali::CallbackBase *)jarg3;
18953   {
18954     try {
18955       (arg1)->SignalConnected(arg2,arg3);
18956     } catch (std::out_of_range& e) {
18957       {
18958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18959       };
18960     } catch (std::exception& e) {
18961       {
18962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18963       };
18964     } catch (Dali::DaliException e) {
18965       {
18966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18967       };
18968     } catch (...) {
18969       {
18970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18971       };
18972     }
18973   }
18974
18975 }
18976
18977
18978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
18979   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
18980   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
18981   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
18982
18983   arg1 = (Dali::ConnectionTracker *)jarg1;
18984   arg2 = (Dali::SlotObserver *)jarg2;
18985   arg3 = (Dali::CallbackBase *)jarg3;
18986   {
18987     try {
18988       (arg1)->SignalDisconnected(arg2,arg3);
18989     } catch (std::out_of_range& e) {
18990       {
18991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18992       };
18993     } catch (std::exception& e) {
18994       {
18995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18996       };
18997     } catch (Dali::DaliException e) {
18998       {
18999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19000       };
19001     } catch (...) {
19002       {
19003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19004       };
19005     }
19006   }
19007
19008 }
19009
19010
19011 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
19012   unsigned long jresult ;
19013   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19014   std::size_t result;
19015
19016   arg1 = (Dali::ConnectionTracker *)jarg1;
19017   {
19018     try {
19019       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
19020     } catch (std::out_of_range& e) {
19021       {
19022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19023       };
19024     } catch (std::exception& e) {
19025       {
19026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19027       };
19028     } catch (Dali::DaliException e) {
19029       {
19030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19031       };
19032     } catch (...) {
19033       {
19034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19035       };
19036     }
19037   }
19038
19039   jresult = (unsigned long)result;
19040   return jresult;
19041 }
19042
19043
19044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
19045   void * jresult ;
19046   Dali::ObjectRegistry *result = 0 ;
19047
19048   {
19049     try {
19050       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
19051     } catch (std::out_of_range& e) {
19052       {
19053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19054       };
19055     } catch (std::exception& e) {
19056       {
19057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19058       };
19059     } catch (Dali::DaliException e) {
19060       {
19061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19062       };
19063     } catch (...) {
19064       {
19065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19066       };
19067     }
19068   }
19069
19070   jresult = (void *)result;
19071   return jresult;
19072 }
19073
19074
19075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
19076   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19077
19078   arg1 = (Dali::ObjectRegistry *)jarg1;
19079   {
19080     try {
19081       delete arg1;
19082     } catch (std::out_of_range& e) {
19083       {
19084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19085       };
19086     } catch (std::exception& e) {
19087       {
19088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19089       };
19090     } catch (Dali::DaliException e) {
19091       {
19092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19093       };
19094     } catch (...) {
19095       {
19096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19097       };
19098     }
19099   }
19100
19101 }
19102
19103
19104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
19105   void * jresult ;
19106   Dali::ObjectRegistry *arg1 = 0 ;
19107   Dali::ObjectRegistry *result = 0 ;
19108
19109   arg1 = (Dali::ObjectRegistry *)jarg1;
19110   if (!arg1) {
19111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19112     return 0;
19113   }
19114   {
19115     try {
19116       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
19117     } catch (std::out_of_range& e) {
19118       {
19119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19120       };
19121     } catch (std::exception& e) {
19122       {
19123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19124       };
19125     } catch (Dali::DaliException e) {
19126       {
19127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19128       };
19129     } catch (...) {
19130       {
19131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19132       };
19133     }
19134   }
19135
19136   jresult = (void *)result;
19137   return jresult;
19138 }
19139
19140
19141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
19142   void * jresult ;
19143   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19144   Dali::ObjectRegistry *arg2 = 0 ;
19145   Dali::ObjectRegistry *result = 0 ;
19146
19147   arg1 = (Dali::ObjectRegistry *)jarg1;
19148   arg2 = (Dali::ObjectRegistry *)jarg2;
19149   if (!arg2) {
19150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19151     return 0;
19152   }
19153   {
19154     try {
19155       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
19156     } catch (std::out_of_range& e) {
19157       {
19158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19159       };
19160     } catch (std::exception& e) {
19161       {
19162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19163       };
19164     } catch (Dali::DaliException e) {
19165       {
19166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19167       };
19168     } catch (...) {
19169       {
19170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19171       };
19172     }
19173   }
19174
19175   jresult = (void *)result;
19176   return jresult;
19177 }
19178
19179
19180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
19181   void * jresult ;
19182   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19183   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
19184
19185   arg1 = (Dali::ObjectRegistry *)jarg1;
19186   {
19187     try {
19188       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
19189     } catch (std::out_of_range& e) {
19190       {
19191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19192       };
19193     } catch (std::exception& e) {
19194       {
19195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19196       };
19197     } catch (Dali::DaliException e) {
19198       {
19199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19200       };
19201     } catch (...) {
19202       {
19203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19204       };
19205     }
19206   }
19207
19208   jresult = (void *)result;
19209   return jresult;
19210 }
19211
19212
19213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
19214   void * jresult ;
19215   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19216   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
19217
19218   arg1 = (Dali::ObjectRegistry *)jarg1;
19219   {
19220     try {
19221       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
19222     } catch (std::out_of_range& e) {
19223       {
19224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19225       };
19226     } catch (std::exception& e) {
19227       {
19228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19229       };
19230     } catch (Dali::DaliException e) {
19231       {
19232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19233       };
19234     } catch (...) {
19235       {
19236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19237       };
19238     }
19239   }
19240
19241   jresult = (void *)result;
19242   return jresult;
19243 }
19244
19245
19246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
19247   void * jresult ;
19248   Dali::PropertyCondition *result = 0 ;
19249
19250   {
19251     try {
19252       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
19253     } catch (std::out_of_range& e) {
19254       {
19255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19256       };
19257     } catch (std::exception& e) {
19258       {
19259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19260       };
19261     } catch (Dali::DaliException e) {
19262       {
19263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19264       };
19265     } catch (...) {
19266       {
19267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19268       };
19269     }
19270   }
19271
19272   jresult = (void *)result;
19273   return jresult;
19274 }
19275
19276
19277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
19278   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19279
19280   arg1 = (Dali::PropertyCondition *)jarg1;
19281   {
19282     try {
19283       delete arg1;
19284     } catch (std::out_of_range& e) {
19285       {
19286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19287       };
19288     } catch (std::exception& e) {
19289       {
19290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19291       };
19292     } catch (Dali::DaliException e) {
19293       {
19294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19295       };
19296     } catch (...) {
19297       {
19298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19299       };
19300     }
19301   }
19302
19303 }
19304
19305
19306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
19307   void * jresult ;
19308   Dali::PropertyCondition *arg1 = 0 ;
19309   Dali::PropertyCondition *result = 0 ;
19310
19311   arg1 = (Dali::PropertyCondition *)jarg1;
19312   if (!arg1) {
19313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19314     return 0;
19315   }
19316   {
19317     try {
19318       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
19319     } catch (std::out_of_range& e) {
19320       {
19321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19322       };
19323     } catch (std::exception& e) {
19324       {
19325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19326       };
19327     } catch (Dali::DaliException e) {
19328       {
19329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19330       };
19331     } catch (...) {
19332       {
19333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19334       };
19335     }
19336   }
19337
19338   jresult = (void *)result;
19339   return jresult;
19340 }
19341
19342
19343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
19344   void * jresult ;
19345   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19346   Dali::PropertyCondition *arg2 = 0 ;
19347   Dali::PropertyCondition *result = 0 ;
19348
19349   arg1 = (Dali::PropertyCondition *)jarg1;
19350   arg2 = (Dali::PropertyCondition *)jarg2;
19351   if (!arg2) {
19352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19353     return 0;
19354   }
19355   {
19356     try {
19357       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
19358     } catch (std::out_of_range& e) {
19359       {
19360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19361       };
19362     } catch (std::exception& e) {
19363       {
19364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19365       };
19366     } catch (Dali::DaliException e) {
19367       {
19368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19369       };
19370     } catch (...) {
19371       {
19372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19373       };
19374     }
19375   }
19376
19377   jresult = (void *)result;
19378   return jresult;
19379 }
19380
19381
19382 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
19383   unsigned long jresult ;
19384   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19385   std::size_t result;
19386
19387   arg1 = (Dali::PropertyCondition *)jarg1;
19388   {
19389     try {
19390       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
19391     } catch (std::out_of_range& e) {
19392       {
19393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19394       };
19395     } catch (std::exception& e) {
19396       {
19397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19398       };
19399     } catch (...) {
19400       {
19401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19402       };
19403     }
19404   }
19405   jresult = (unsigned long)result;
19406   return jresult;
19407 }
19408
19409
19410 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
19411   float jresult ;
19412   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19413   std::size_t arg2 ;
19414   float result;
19415
19416   arg1 = (Dali::PropertyCondition *)jarg1;
19417   arg2 = (std::size_t)jarg2;
19418   {
19419     try {
19420       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
19421     } catch (std::out_of_range& e) {
19422       {
19423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19424       };
19425     } catch (std::exception& e) {
19426       {
19427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19428       };
19429     } catch (...) {
19430       {
19431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19432       };
19433     }
19434   }
19435   jresult = result;
19436   return jresult;
19437 }
19438
19439
19440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
19441   void * jresult ;
19442   float arg1 ;
19443   Dali::PropertyCondition result;
19444
19445   arg1 = (float)jarg1;
19446   {
19447     try {
19448       result = Dali::LessThanCondition(arg1);
19449     } catch (std::out_of_range& e) {
19450       {
19451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19452       };
19453     } catch (std::exception& e) {
19454       {
19455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19456       };
19457     } catch (Dali::DaliException e) {
19458       {
19459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19460       };
19461     } catch (...) {
19462       {
19463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19464       };
19465     }
19466   }
19467
19468   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19469   return jresult;
19470 }
19471
19472
19473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
19474   void * jresult ;
19475   float arg1 ;
19476   Dali::PropertyCondition result;
19477
19478   arg1 = (float)jarg1;
19479   {
19480     try {
19481       result = Dali::GreaterThanCondition(arg1);
19482     } catch (std::out_of_range& e) {
19483       {
19484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19485       };
19486     } catch (std::exception& e) {
19487       {
19488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19489       };
19490     } catch (Dali::DaliException e) {
19491       {
19492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19493       };
19494     } catch (...) {
19495       {
19496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19497       };
19498     }
19499   }
19500
19501   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19502   return jresult;
19503 }
19504
19505
19506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
19507   void * jresult ;
19508   float arg1 ;
19509   float arg2 ;
19510   Dali::PropertyCondition result;
19511
19512   arg1 = (float)jarg1;
19513   arg2 = (float)jarg2;
19514   {
19515     try {
19516       result = Dali::InsideCondition(arg1,arg2);
19517     } catch (std::out_of_range& e) {
19518       {
19519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19520       };
19521     } catch (std::exception& e) {
19522       {
19523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19524       };
19525     } catch (Dali::DaliException e) {
19526       {
19527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19528       };
19529     } catch (...) {
19530       {
19531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19532       };
19533     }
19534   }
19535
19536   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19537   return jresult;
19538 }
19539
19540
19541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
19542   void * jresult ;
19543   float arg1 ;
19544   float arg2 ;
19545   Dali::PropertyCondition result;
19546
19547   arg1 = (float)jarg1;
19548   arg2 = (float)jarg2;
19549   {
19550     try {
19551       result = Dali::OutsideCondition(arg1,arg2);
19552     } catch (std::out_of_range& e) {
19553       {
19554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19555       };
19556     } catch (std::exception& e) {
19557       {
19558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19559       };
19560     } catch (Dali::DaliException e) {
19561       {
19562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19563       };
19564     } catch (...) {
19565       {
19566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19567       };
19568     }
19569   }
19570
19571   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19572   return jresult;
19573 }
19574
19575
19576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
19577   void * jresult ;
19578   float arg1 ;
19579   float arg2 ;
19580   Dali::PropertyCondition result;
19581
19582   arg1 = (float)jarg1;
19583   arg2 = (float)jarg2;
19584   {
19585     try {
19586       result = Dali::StepCondition(arg1,arg2);
19587     } catch (std::out_of_range& e) {
19588       {
19589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19590       };
19591     } catch (std::exception& e) {
19592       {
19593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19594       };
19595     } catch (Dali::DaliException e) {
19596       {
19597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19598       };
19599     } catch (...) {
19600       {
19601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19602       };
19603     }
19604   }
19605
19606   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19607   return jresult;
19608 }
19609
19610
19611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
19612   void * jresult ;
19613   float arg1 ;
19614   Dali::PropertyCondition result;
19615
19616   arg1 = (float)jarg1;
19617   {
19618     try {
19619       result = Dali::StepCondition(arg1);
19620     } catch (std::out_of_range& e) {
19621       {
19622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19623       };
19624     } catch (std::exception& e) {
19625       {
19626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19627       };
19628     } catch (Dali::DaliException e) {
19629       {
19630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19631       };
19632     } catch (...) {
19633       {
19634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19635       };
19636     }
19637   }
19638
19639   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19640   return jresult;
19641 }
19642
19643
19644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
19645   void * jresult ;
19646   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
19647   Dali::PropertyCondition result;
19648
19649   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
19650   if (!arg1) {
19651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
19652     return 0;
19653   }
19654   {
19655     try {
19656       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
19657     } catch (std::out_of_range& e) {
19658       {
19659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19660       };
19661     } catch (std::exception& e) {
19662       {
19663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19664       };
19665     } catch (Dali::DaliException e) {
19666       {
19667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19668       };
19669     } catch (...) {
19670       {
19671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19672       };
19673     }
19674   }
19675
19676   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19677   return jresult;
19678 }
19679
19680
19681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
19682   void * jresult ;
19683   Dali::PropertyNotification *result = 0 ;
19684
19685   {
19686     try {
19687       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
19688     } catch (std::out_of_range& e) {
19689       {
19690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19691       };
19692     } catch (std::exception& e) {
19693       {
19694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19695       };
19696     } catch (Dali::DaliException e) {
19697       {
19698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19699       };
19700     } catch (...) {
19701       {
19702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19703       };
19704     }
19705   }
19706
19707   jresult = (void *)result;
19708   return jresult;
19709 }
19710
19711
19712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
19713   void * jresult ;
19714   Dali::BaseHandle arg1 ;
19715   Dali::BaseHandle *argp1 ;
19716   Dali::PropertyNotification result;
19717
19718   argp1 = (Dali::BaseHandle *)jarg1;
19719   if (!argp1) {
19720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19721     return 0;
19722   }
19723   arg1 = *argp1;
19724   {
19725     try {
19726       result = Dali::PropertyNotification::DownCast(arg1);
19727     } catch (std::out_of_range& e) {
19728       {
19729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19730       };
19731     } catch (std::exception& e) {
19732       {
19733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19734       };
19735     } catch (Dali::DaliException e) {
19736       {
19737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19738       };
19739     } catch (...) {
19740       {
19741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19742       };
19743     }
19744   }
19745
19746   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
19747   return jresult;
19748 }
19749
19750
19751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
19752   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19753
19754   arg1 = (Dali::PropertyNotification *)jarg1;
19755   {
19756     try {
19757       delete arg1;
19758     } catch (std::out_of_range& e) {
19759       {
19760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19761       };
19762     } catch (std::exception& e) {
19763       {
19764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19765       };
19766     } catch (Dali::DaliException e) {
19767       {
19768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19769       };
19770     } catch (...) {
19771       {
19772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19773       };
19774     }
19775   }
19776
19777 }
19778
19779
19780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
19781   void * jresult ;
19782   Dali::PropertyNotification *arg1 = 0 ;
19783   Dali::PropertyNotification *result = 0 ;
19784
19785   arg1 = (Dali::PropertyNotification *)jarg1;
19786   if (!arg1) {
19787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19788     return 0;
19789   }
19790   {
19791     try {
19792       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
19793     } catch (std::out_of_range& e) {
19794       {
19795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19796       };
19797     } catch (std::exception& e) {
19798       {
19799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19800       };
19801     } catch (Dali::DaliException e) {
19802       {
19803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19804       };
19805     } catch (...) {
19806       {
19807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19808       };
19809     }
19810   }
19811
19812   jresult = (void *)result;
19813   return jresult;
19814 }
19815
19816
19817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
19818   void * jresult ;
19819   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19820   Dali::PropertyNotification *arg2 = 0 ;
19821   Dali::PropertyNotification *result = 0 ;
19822
19823   arg1 = (Dali::PropertyNotification *)jarg1;
19824   arg2 = (Dali::PropertyNotification *)jarg2;
19825   if (!arg2) {
19826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19827     return 0;
19828   }
19829   {
19830     try {
19831       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
19832     } catch (std::out_of_range& e) {
19833       {
19834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19835       };
19836     } catch (std::exception& e) {
19837       {
19838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19839       };
19840     } catch (Dali::DaliException e) {
19841       {
19842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19843       };
19844     } catch (...) {
19845       {
19846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19847       };
19848     }
19849   }
19850
19851   jresult = (void *)result;
19852   return jresult;
19853 }
19854
19855
19856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
19857   void * jresult ;
19858   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19859   Dali::PropertyCondition result;
19860
19861   arg1 = (Dali::PropertyNotification *)jarg1;
19862   {
19863     try {
19864       result = (arg1)->GetCondition();
19865     } catch (std::out_of_range& e) {
19866       {
19867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19868       };
19869     } catch (std::exception& e) {
19870       {
19871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19872       };
19873     } catch (Dali::DaliException e) {
19874       {
19875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19876       };
19877     } catch (...) {
19878       {
19879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19880       };
19881     }
19882   }
19883
19884   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19885   return jresult;
19886 }
19887
19888
19889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
19890   void * jresult ;
19891   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19892   Dali::Handle result;
19893
19894   arg1 = (Dali::PropertyNotification *)jarg1;
19895   {
19896     try {
19897       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
19898     } catch (std::out_of_range& e) {
19899       {
19900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19901       };
19902     } catch (std::exception& e) {
19903       {
19904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19905       };
19906     } catch (Dali::DaliException e) {
19907       {
19908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19909       };
19910     } catch (...) {
19911       {
19912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19913       };
19914     }
19915   }
19916
19917   jresult = new Dali::Handle((const Dali::Handle &)result);
19918   return jresult;
19919 }
19920
19921
19922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
19923   int jresult ;
19924   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19925   Dali::Property::Index result;
19926
19927   arg1 = (Dali::PropertyNotification *)jarg1;
19928   {
19929     try {
19930       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
19931     } catch (std::out_of_range& e) {
19932       {
19933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19934       };
19935     } catch (std::exception& e) {
19936       {
19937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19938       };
19939     } catch (Dali::DaliException e) {
19940       {
19941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19942       };
19943     } catch (...) {
19944       {
19945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19946       };
19947     }
19948   }
19949
19950   jresult = result;
19951   return jresult;
19952 }
19953
19954
19955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
19956   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19957   Dali::PropertyNotification::NotifyMode arg2 ;
19958
19959   arg1 = (Dali::PropertyNotification *)jarg1;
19960   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
19961   {
19962     try {
19963       (arg1)->SetNotifyMode(arg2);
19964     } catch (std::out_of_range& e) {
19965       {
19966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19967       };
19968     } catch (std::exception& e) {
19969       {
19970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19971       };
19972     } catch (Dali::DaliException e) {
19973       {
19974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19975       };
19976     } catch (...) {
19977       {
19978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19979       };
19980     }
19981   }
19982
19983 }
19984
19985
19986 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
19987   int jresult ;
19988   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19989   Dali::PropertyNotification::NotifyMode result;
19990
19991   arg1 = (Dali::PropertyNotification *)jarg1;
19992   {
19993     try {
19994       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
19995     } catch (std::out_of_range& e) {
19996       {
19997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19998       };
19999     } catch (std::exception& e) {
20000       {
20001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20002       };
20003     } catch (Dali::DaliException e) {
20004       {
20005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20006       };
20007     } catch (...) {
20008       {
20009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20010       };
20011     }
20012   }
20013
20014   jresult = (int)result;
20015   return jresult;
20016 }
20017
20018
20019 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
20020   unsigned int jresult ;
20021   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20022   bool result;
20023
20024   arg1 = (Dali::PropertyNotification *)jarg1;
20025   {
20026     try {
20027       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
20028     } catch (std::out_of_range& e) {
20029       {
20030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20031       };
20032     } catch (std::exception& e) {
20033       {
20034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20035       };
20036     } catch (Dali::DaliException e) {
20037       {
20038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20039       };
20040     } catch (...) {
20041       {
20042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20043       };
20044     }
20045   }
20046
20047   jresult = result;
20048   return jresult;
20049 }
20050
20051
20052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
20053   void * jresult ;
20054   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20055   Dali::PropertyNotifySignalType *result = 0 ;
20056
20057   arg1 = (Dali::PropertyNotification *)jarg1;
20058   {
20059     try {
20060       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
20061     } catch (std::out_of_range& e) {
20062       {
20063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20064       };
20065     } catch (std::exception& e) {
20066       {
20067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20068       };
20069     } catch (Dali::DaliException e) {
20070       {
20071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20072       };
20073     } catch (...) {
20074       {
20075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20076       };
20077     }
20078   }
20079
20080   jresult = (void *)result;
20081   return jresult;
20082 }
20083
20084
20085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
20086   void * jresult ;
20087   Dali::Handle *result = 0 ;
20088
20089   {
20090     try {
20091       result = (Dali::Handle *)new Dali::Handle();
20092     } catch (std::out_of_range& e) {
20093       {
20094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20095       };
20096     } catch (std::exception& e) {
20097       {
20098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20099       };
20100     } catch (Dali::DaliException e) {
20101       {
20102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20103       };
20104     } catch (...) {
20105       {
20106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20107       };
20108     }
20109   }
20110
20111   jresult = (void *)result;
20112   return jresult;
20113 }
20114
20115
20116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
20117   void * jresult ;
20118   Dali::Handle result;
20119
20120   {
20121     try {
20122       result = Dali::Handle::New();
20123     } catch (std::out_of_range& e) {
20124       {
20125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20126       };
20127     } catch (std::exception& e) {
20128       {
20129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20130       };
20131     } catch (Dali::DaliException e) {
20132       {
20133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20134       };
20135     } catch (...) {
20136       {
20137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20138       };
20139     }
20140   }
20141
20142   jresult = new Dali::Handle((const Dali::Handle &)result);
20143   return jresult;
20144 }
20145
20146
20147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
20148   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20149
20150   arg1 = (Dali::Handle *)jarg1;
20151   {
20152     try {
20153       delete arg1;
20154     } catch (std::out_of_range& e) {
20155       {
20156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20157       };
20158     } catch (std::exception& e) {
20159       {
20160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20161       };
20162     } catch (Dali::DaliException e) {
20163       {
20164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20165       };
20166     } catch (...) {
20167       {
20168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20169       };
20170     }
20171   }
20172
20173 }
20174
20175
20176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
20177   void * jresult ;
20178   Dali::Handle *arg1 = 0 ;
20179   Dali::Handle *result = 0 ;
20180
20181   arg1 = (Dali::Handle *)jarg1;
20182   if (!arg1) {
20183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20184     return 0;
20185   }
20186   {
20187     try {
20188       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
20189     } catch (std::out_of_range& e) {
20190       {
20191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20192       };
20193     } catch (std::exception& e) {
20194       {
20195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20196       };
20197     } catch (Dali::DaliException e) {
20198       {
20199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20200       };
20201     } catch (...) {
20202       {
20203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20204       };
20205     }
20206   }
20207
20208   jresult = (void *)result;
20209   return jresult;
20210 }
20211
20212
20213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
20214   void * jresult ;
20215   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20216   Dali::Handle *arg2 = 0 ;
20217   Dali::Handle *result = 0 ;
20218
20219   arg1 = (Dali::Handle *)jarg1;
20220   arg2 = (Dali::Handle *)jarg2;
20221   if (!arg2) {
20222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20223     return 0;
20224   }
20225   {
20226     try {
20227       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
20228     } catch (std::out_of_range& e) {
20229       {
20230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20231       };
20232     } catch (std::exception& e) {
20233       {
20234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20235       };
20236     } catch (Dali::DaliException e) {
20237       {
20238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20239       };
20240     } catch (...) {
20241       {
20242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20243       };
20244     }
20245   }
20246
20247   jresult = (void *)result;
20248   return jresult;
20249 }
20250
20251
20252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
20253   void * jresult ;
20254   Dali::BaseHandle arg1 ;
20255   Dali::BaseHandle *argp1 ;
20256   Dali::Handle result;
20257
20258   argp1 = (Dali::BaseHandle *)jarg1;
20259   if (!argp1) {
20260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20261     return 0;
20262   }
20263   arg1 = *argp1;
20264   {
20265     try {
20266       result = Dali::Handle::DownCast(arg1);
20267     } catch (std::out_of_range& e) {
20268       {
20269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20270       };
20271     } catch (std::exception& e) {
20272       {
20273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20274       };
20275     } catch (Dali::DaliException e) {
20276       {
20277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20278       };
20279     } catch (...) {
20280       {
20281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20282       };
20283     }
20284   }
20285
20286   jresult = new Dali::Handle((const Dali::Handle &)result);
20287   return jresult;
20288 }
20289
20290
20291 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
20292   unsigned int jresult ;
20293   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20294   Dali::Handle::Capability arg2 ;
20295   bool result;
20296
20297   arg1 = (Dali::Handle *)jarg1;
20298   arg2 = (Dali::Handle::Capability)jarg2;
20299   {
20300     try {
20301       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
20302     } catch (std::out_of_range& e) {
20303       {
20304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20305       };
20306     } catch (std::exception& e) {
20307       {
20308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20309       };
20310     } catch (Dali::DaliException e) {
20311       {
20312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20313       };
20314     } catch (...) {
20315       {
20316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20317       };
20318     }
20319   }
20320
20321   jresult = result;
20322   return jresult;
20323 }
20324
20325
20326 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
20327   unsigned int jresult ;
20328   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20329   unsigned int result;
20330
20331   arg1 = (Dali::Handle *)jarg1;
20332   {
20333     try {
20334       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
20335     } catch (std::out_of_range& e) {
20336       {
20337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20338       };
20339     } catch (std::exception& e) {
20340       {
20341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20342       };
20343     } catch (Dali::DaliException e) {
20344       {
20345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20346       };
20347     } catch (...) {
20348       {
20349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20350       };
20351     }
20352   }
20353
20354   jresult = result;
20355   return jresult;
20356 }
20357
20358
20359 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
20360   char * jresult ;
20361   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20362   Dali::Property::Index arg2 ;
20363   std::string result;
20364
20365   arg1 = (Dali::Handle *)jarg1;
20366   arg2 = (Dali::Property::Index)jarg2;
20367   {
20368     try {
20369       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
20370     } catch (std::out_of_range& e) {
20371       {
20372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20373       };
20374     } catch (std::exception& e) {
20375       {
20376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20377       };
20378     } catch (Dali::DaliException e) {
20379       {
20380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20381       };
20382     } catch (...) {
20383       {
20384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20385       };
20386     }
20387   }
20388
20389   jresult = SWIG_csharp_string_callback((&result)->c_str());
20390   return jresult;
20391 }
20392
20393
20394 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
20395   int jresult ;
20396   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20397   std::string *arg2 = 0 ;
20398   Dali::Property::Index result;
20399
20400   arg1 = (Dali::Handle *)jarg1;
20401   if (!jarg2) {
20402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20403     return 0;
20404   }
20405   std::string arg2_str(jarg2);
20406   arg2 = &arg2_str;
20407   {
20408     try {
20409       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
20410     } catch (std::out_of_range& e) {
20411       {
20412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20413       };
20414     } catch (std::exception& e) {
20415       {
20416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20417       };
20418     } catch (Dali::DaliException e) {
20419       {
20420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20421       };
20422     } catch (...) {
20423       {
20424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20425       };
20426     }
20427   }
20428
20429   jresult = result;
20430
20431   //argout typemap for const std::string&
20432
20433   return jresult;
20434 }
20435
20436
20437 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
20438   unsigned int jresult ;
20439   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20440   Dali::Property::Index arg2 ;
20441   bool result;
20442
20443   arg1 = (Dali::Handle *)jarg1;
20444   arg2 = (Dali::Property::Index)jarg2;
20445   {
20446     try {
20447       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
20448     } catch (std::out_of_range& e) {
20449       {
20450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20451       };
20452     } catch (std::exception& e) {
20453       {
20454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20455       };
20456     } catch (Dali::DaliException e) {
20457       {
20458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20459       };
20460     } catch (...) {
20461       {
20462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20463       };
20464     }
20465   }
20466
20467   jresult = result;
20468   return jresult;
20469 }
20470
20471
20472 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
20473   unsigned int jresult ;
20474   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20475   Dali::Property::Index arg2 ;
20476   bool result;
20477
20478   arg1 = (Dali::Handle *)jarg1;
20479   arg2 = (Dali::Property::Index)jarg2;
20480   {
20481     try {
20482       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
20483     } catch (std::out_of_range& e) {
20484       {
20485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20486       };
20487     } catch (std::exception& e) {
20488       {
20489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20490       };
20491     } catch (Dali::DaliException e) {
20492       {
20493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20494       };
20495     } catch (...) {
20496       {
20497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20498       };
20499     }
20500   }
20501
20502   jresult = result;
20503   return jresult;
20504 }
20505
20506
20507 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
20508   unsigned int jresult ;
20509   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20510   Dali::Property::Index arg2 ;
20511   bool result;
20512
20513   arg1 = (Dali::Handle *)jarg1;
20514   arg2 = (Dali::Property::Index)jarg2;
20515   {
20516     try {
20517       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
20518     } catch (std::out_of_range& e) {
20519       {
20520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20521       };
20522     } catch (std::exception& e) {
20523       {
20524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20525       };
20526     } catch (Dali::DaliException e) {
20527       {
20528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20529       };
20530     } catch (...) {
20531       {
20532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20533       };
20534     }
20535   }
20536
20537   jresult = result;
20538   return jresult;
20539 }
20540
20541
20542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
20543   int jresult ;
20544   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20545   Dali::Property::Index arg2 ;
20546   Dali::Property::Type result;
20547
20548   arg1 = (Dali::Handle *)jarg1;
20549   arg2 = (Dali::Property::Index)jarg2;
20550   {
20551     try {
20552       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
20553     } catch (std::out_of_range& e) {
20554       {
20555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20556       };
20557     } catch (std::exception& e) {
20558       {
20559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20560       };
20561     } catch (Dali::DaliException e) {
20562       {
20563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20564       };
20565     } catch (...) {
20566       {
20567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20568       };
20569     }
20570   }
20571
20572   jresult = (int)result;
20573   return jresult;
20574 }
20575
20576
20577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
20578   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20579   Dali::Property::Index arg2 ;
20580   Dali::Property::Value *arg3 = 0 ;
20581
20582   arg1 = (Dali::Handle *)jarg1;
20583   arg2 = (Dali::Property::Index)jarg2;
20584   arg3 = (Dali::Property::Value *)jarg3;
20585   if (!arg3) {
20586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20587     return ;
20588   }
20589   {
20590     try {
20591       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
20592     } catch (std::out_of_range& e) {
20593       {
20594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20595       };
20596     } catch (std::exception& e) {
20597       {
20598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20599       };
20600     } catch (Dali::DaliException e) {
20601       {
20602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20603       };
20604     } catch (...) {
20605       {
20606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20607       };
20608     }
20609   }
20610
20611 }
20612
20613
20614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
20615   int jresult ;
20616   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20617   std::string *arg2 = 0 ;
20618   Dali::Property::Value *arg3 = 0 ;
20619   Dali::Property::Index result;
20620
20621   arg1 = (Dali::Handle *)jarg1;
20622   if (!jarg2) {
20623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20624     return 0;
20625   }
20626   std::string arg2_str(jarg2);
20627   arg2 = &arg2_str;
20628   arg3 = (Dali::Property::Value *)jarg3;
20629   if (!arg3) {
20630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20631     return 0;
20632   }
20633   {
20634     try {
20635       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
20636     } catch (std::out_of_range& e) {
20637       {
20638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20639       };
20640     } catch (std::exception& e) {
20641       {
20642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20643       };
20644     } catch (Dali::DaliException e) {
20645       {
20646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20647       };
20648     } catch (...) {
20649       {
20650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20651       };
20652     }
20653   }
20654
20655   jresult = result;
20656
20657   //argout typemap for const std::string&
20658
20659   return jresult;
20660 }
20661
20662
20663 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
20664   int jresult ;
20665   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20666   std::string *arg2 = 0 ;
20667   Dali::Property::Value *arg3 = 0 ;
20668   Dali::Property::AccessMode arg4 ;
20669   Dali::Property::Index result;
20670
20671   arg1 = (Dali::Handle *)jarg1;
20672   if (!jarg2) {
20673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20674     return 0;
20675   }
20676   std::string arg2_str(jarg2);
20677   arg2 = &arg2_str;
20678   arg3 = (Dali::Property::Value *)jarg3;
20679   if (!arg3) {
20680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20681     return 0;
20682   }
20683   arg4 = (Dali::Property::AccessMode)jarg4;
20684   {
20685     try {
20686       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
20687     } catch (std::out_of_range& e) {
20688       {
20689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20690       };
20691     } catch (std::exception& e) {
20692       {
20693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20694       };
20695     } catch (Dali::DaliException e) {
20696       {
20697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20698       };
20699     } catch (...) {
20700       {
20701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20702       };
20703     }
20704   }
20705
20706   jresult = result;
20707
20708   //argout typemap for const std::string&
20709
20710   return jresult;
20711 }
20712
20713
20714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
20715   void * jresult ;
20716   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20717   Dali::Property::Index arg2 ;
20718   Dali::Property::Value result;
20719
20720   arg1 = (Dali::Handle *)jarg1;
20721   arg2 = (Dali::Property::Index)jarg2;
20722   {
20723     try {
20724       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
20725     } catch (std::out_of_range& e) {
20726       {
20727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20728       };
20729     } catch (std::exception& e) {
20730       {
20731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20732       };
20733     } catch (Dali::DaliException e) {
20734       {
20735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20736       };
20737     } catch (...) {
20738       {
20739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20740       };
20741     }
20742   }
20743
20744   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
20745   return jresult;
20746 }
20747
20748
20749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
20750   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20751   Dali::Property::IndexContainer *arg2 = 0 ;
20752
20753   arg1 = (Dali::Handle *)jarg1;
20754   arg2 = (Dali::Property::IndexContainer *)jarg2;
20755   if (!arg2) {
20756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
20757     return ;
20758   }
20759   {
20760     try {
20761       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
20762     } catch (std::out_of_range& e) {
20763       {
20764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20765       };
20766     } catch (std::exception& e) {
20767       {
20768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20769       };
20770     } catch (Dali::DaliException e) {
20771       {
20772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20773       };
20774     } catch (...) {
20775       {
20776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20777       };
20778     }
20779   }
20780
20781 }
20782
20783
20784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
20785   void * jresult ;
20786   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20787   Dali::Property::Index arg2 ;
20788   Dali::PropertyCondition *arg3 = 0 ;
20789   Dali::PropertyNotification result;
20790
20791   arg1 = (Dali::Handle *)jarg1;
20792   arg2 = (Dali::Property::Index)jarg2;
20793   arg3 = (Dali::PropertyCondition *)jarg3;
20794   if (!arg3) {
20795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20796     return 0;
20797   }
20798   {
20799     try {
20800       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
20801     } catch (std::out_of_range& e) {
20802       {
20803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20804       };
20805     } catch (std::exception& e) {
20806       {
20807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20808       };
20809     } catch (Dali::DaliException e) {
20810       {
20811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20812       };
20813     } catch (...) {
20814       {
20815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20816       };
20817     }
20818   }
20819
20820   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
20821   return jresult;
20822 }
20823
20824
20825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
20826   void * jresult ;
20827   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20828   Dali::Property::Index arg2 ;
20829   int arg3 ;
20830   Dali::PropertyCondition *arg4 = 0 ;
20831   Dali::PropertyNotification result;
20832
20833   arg1 = (Dali::Handle *)jarg1;
20834   arg2 = (Dali::Property::Index)jarg2;
20835   arg3 = (int)jarg3;
20836   arg4 = (Dali::PropertyCondition *)jarg4;
20837   if (!arg4) {
20838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20839     return 0;
20840   }
20841   {
20842     try {
20843       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
20844     } catch (std::out_of_range& e) {
20845       {
20846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20847       };
20848     } catch (std::exception& e) {
20849       {
20850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20851       };
20852     } catch (Dali::DaliException e) {
20853       {
20854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20855       };
20856     } catch (...) {
20857       {
20858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20859       };
20860     }
20861   }
20862
20863   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
20864   return jresult;
20865 }
20866
20867
20868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
20869   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20870   Dali::PropertyNotification arg2 ;
20871   Dali::PropertyNotification *argp2 ;
20872
20873   arg1 = (Dali::Handle *)jarg1;
20874   argp2 = (Dali::PropertyNotification *)jarg2;
20875   if (!argp2) {
20876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
20877     return ;
20878   }
20879   arg2 = *argp2;
20880   {
20881     try {
20882       (arg1)->RemovePropertyNotification(arg2);
20883     } catch (std::out_of_range& e) {
20884       {
20885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20886       };
20887     } catch (std::exception& e) {
20888       {
20889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20890       };
20891     } catch (Dali::DaliException e) {
20892       {
20893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20894       };
20895     } catch (...) {
20896       {
20897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20898       };
20899     }
20900   }
20901
20902 }
20903
20904
20905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
20906   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20907
20908   arg1 = (Dali::Handle *)jarg1;
20909   {
20910     try {
20911       (arg1)->RemovePropertyNotifications();
20912     } catch (std::out_of_range& e) {
20913       {
20914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20915       };
20916     } catch (std::exception& e) {
20917       {
20918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20919       };
20920     } catch (Dali::DaliException e) {
20921       {
20922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20923       };
20924     } catch (...) {
20925       {
20926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20927       };
20928     }
20929   }
20930
20931 }
20932
20933
20934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
20935   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20936
20937   arg1 = (Dali::Handle *)jarg1;
20938   {
20939     try {
20940       (arg1)->RemoveConstraints();
20941     } catch (std::out_of_range& e) {
20942       {
20943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20944       };
20945     } catch (std::exception& e) {
20946       {
20947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20948       };
20949     } catch (Dali::DaliException e) {
20950       {
20951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20952       };
20953     } catch (...) {
20954       {
20955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20956       };
20957     }
20958   }
20959
20960 }
20961
20962
20963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
20964   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20965   unsigned int arg2 ;
20966
20967   arg1 = (Dali::Handle *)jarg1;
20968   arg2 = (unsigned int)jarg2;
20969   {
20970     try {
20971       (arg1)->RemoveConstraints(arg2);
20972     } catch (std::out_of_range& e) {
20973       {
20974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20975       };
20976     } catch (std::exception& e) {
20977       {
20978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20979       };
20980     } catch (Dali::DaliException e) {
20981       {
20982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20983       };
20984     } catch (...) {
20985       {
20986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20987       };
20988     }
20989   }
20990
20991 }
20992
20993
20994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
20995   int jresult ;
20996   Dali::Property::Index result;
20997
20998   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
20999   jresult = result;
21000   return jresult;
21001 }
21002
21003
21004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
21005   void * jresult ;
21006   Dali::Handle result;
21007
21008   {
21009     try {
21010       result = Dali::WeightObject::New();
21011     } catch (std::out_of_range& e) {
21012       {
21013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21014       };
21015     } catch (std::exception& e) {
21016       {
21017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21018       };
21019     } catch (Dali::DaliException e) {
21020       {
21021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21022       };
21023     } catch (...) {
21024       {
21025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21026       };
21027     }
21028   }
21029
21030   jresult = new Dali::Handle((const Dali::Handle &)result);
21031   return jresult;
21032 }
21033
21034
21035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
21036   void * jresult ;
21037   Dali::TypeInfo *result = 0 ;
21038
21039   {
21040     try {
21041       result = (Dali::TypeInfo *)new Dali::TypeInfo();
21042     } catch (std::out_of_range& e) {
21043       {
21044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21045       };
21046     } catch (std::exception& e) {
21047       {
21048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21049       };
21050     } catch (Dali::DaliException e) {
21051       {
21052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21053       };
21054     } catch (...) {
21055       {
21056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21057       };
21058     }
21059   }
21060
21061   jresult = (void *)result;
21062   return jresult;
21063 }
21064
21065
21066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
21067   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21068
21069   arg1 = (Dali::TypeInfo *)jarg1;
21070   {
21071     try {
21072       delete arg1;
21073     } catch (std::out_of_range& e) {
21074       {
21075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21076       };
21077     } catch (std::exception& e) {
21078       {
21079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21080       };
21081     } catch (Dali::DaliException e) {
21082       {
21083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21084       };
21085     } catch (...) {
21086       {
21087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21088       };
21089     }
21090   }
21091
21092 }
21093
21094
21095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
21096   void * jresult ;
21097   Dali::TypeInfo *arg1 = 0 ;
21098   Dali::TypeInfo *result = 0 ;
21099
21100   arg1 = (Dali::TypeInfo *)jarg1;
21101   if (!arg1) {
21102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21103     return 0;
21104   }
21105   {
21106     try {
21107       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
21108     } catch (std::out_of_range& e) {
21109       {
21110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21111       };
21112     } catch (std::exception& e) {
21113       {
21114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21115       };
21116     } catch (Dali::DaliException e) {
21117       {
21118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21119       };
21120     } catch (...) {
21121       {
21122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21123       };
21124     }
21125   }
21126
21127   jresult = (void *)result;
21128   return jresult;
21129 }
21130
21131
21132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
21133   void * jresult ;
21134   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21135   Dali::TypeInfo *arg2 = 0 ;
21136   Dali::TypeInfo *result = 0 ;
21137
21138   arg1 = (Dali::TypeInfo *)jarg1;
21139   arg2 = (Dali::TypeInfo *)jarg2;
21140   if (!arg2) {
21141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21142     return 0;
21143   }
21144   {
21145     try {
21146       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
21147     } catch (std::out_of_range& e) {
21148       {
21149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21150       };
21151     } catch (std::exception& e) {
21152       {
21153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21154       };
21155     } catch (Dali::DaliException e) {
21156       {
21157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21158       };
21159     } catch (...) {
21160       {
21161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21162       };
21163     }
21164   }
21165
21166   jresult = (void *)result;
21167   return jresult;
21168 }
21169
21170
21171 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
21172   char * jresult ;
21173   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21174   std::string *result = 0 ;
21175
21176   arg1 = (Dali::TypeInfo *)jarg1;
21177   {
21178     try {
21179       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
21180     } catch (std::out_of_range& e) {
21181       {
21182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21183       };
21184     } catch (std::exception& e) {
21185       {
21186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21187       };
21188     } catch (Dali::DaliException e) {
21189       {
21190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21191       };
21192     } catch (...) {
21193       {
21194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21195       };
21196     }
21197   }
21198
21199   jresult = SWIG_csharp_string_callback(result->c_str());
21200   return jresult;
21201 }
21202
21203
21204 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
21205   char * jresult ;
21206   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21207   std::string *result = 0 ;
21208
21209   arg1 = (Dali::TypeInfo *)jarg1;
21210   {
21211     try {
21212       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
21213     } catch (std::out_of_range& e) {
21214       {
21215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21216       };
21217     } catch (std::exception& e) {
21218       {
21219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21220       };
21221     } catch (Dali::DaliException e) {
21222       {
21223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21224       };
21225     } catch (...) {
21226       {
21227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21228       };
21229     }
21230   }
21231
21232   jresult = SWIG_csharp_string_callback(result->c_str());
21233   return jresult;
21234 }
21235
21236
21237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
21238   void * jresult ;
21239   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21240   Dali::BaseHandle result;
21241
21242   arg1 = (Dali::TypeInfo *)jarg1;
21243   {
21244     try {
21245       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
21246     } catch (std::out_of_range& e) {
21247       {
21248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21249       };
21250     } catch (std::exception& e) {
21251       {
21252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21253       };
21254     } catch (Dali::DaliException e) {
21255       {
21256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21257       };
21258     } catch (...) {
21259       {
21260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21261       };
21262     }
21263   }
21264
21265   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
21266   return jresult;
21267 }
21268
21269
21270 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
21271   unsigned long jresult ;
21272   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21273   size_t result;
21274
21275   arg1 = (Dali::TypeInfo *)jarg1;
21276   {
21277     try {
21278       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
21279     } catch (std::out_of_range& e) {
21280       {
21281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21282       };
21283     } catch (std::exception& e) {
21284       {
21285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21286       };
21287     } catch (Dali::DaliException e) {
21288       {
21289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21290       };
21291     } catch (...) {
21292       {
21293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21294       };
21295     }
21296   }
21297
21298   jresult = (unsigned long)result;
21299   return jresult;
21300 }
21301
21302
21303 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
21304   char * jresult ;
21305   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21306   size_t arg2 ;
21307   std::string result;
21308
21309   arg1 = (Dali::TypeInfo *)jarg1;
21310   arg2 = (size_t)jarg2;
21311   {
21312     try {
21313       result = (arg1)->GetActionName(arg2);
21314     } catch (std::out_of_range& e) {
21315       {
21316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21317       };
21318     } catch (std::exception& e) {
21319       {
21320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21321       };
21322     } catch (Dali::DaliException e) {
21323       {
21324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21325       };
21326     } catch (...) {
21327       {
21328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21329       };
21330     }
21331   }
21332
21333   jresult = SWIG_csharp_string_callback((&result)->c_str());
21334   return jresult;
21335 }
21336
21337
21338 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
21339   unsigned long jresult ;
21340   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21341   size_t result;
21342
21343   arg1 = (Dali::TypeInfo *)jarg1;
21344   {
21345     try {
21346       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
21347     } catch (std::out_of_range& e) {
21348       {
21349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21350       };
21351     } catch (std::exception& e) {
21352       {
21353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21354       };
21355     } catch (Dali::DaliException e) {
21356       {
21357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21358       };
21359     } catch (...) {
21360       {
21361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21362       };
21363     }
21364   }
21365
21366   jresult = (unsigned long)result;
21367   return jresult;
21368 }
21369
21370
21371 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
21372   char * jresult ;
21373   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21374   size_t arg2 ;
21375   std::string result;
21376
21377   arg1 = (Dali::TypeInfo *)jarg1;
21378   arg2 = (size_t)jarg2;
21379   {
21380     try {
21381       result = (arg1)->GetSignalName(arg2);
21382     } catch (std::out_of_range& e) {
21383       {
21384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21385       };
21386     } catch (std::exception& e) {
21387       {
21388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21389       };
21390     } catch (Dali::DaliException e) {
21391       {
21392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21393       };
21394     } catch (...) {
21395       {
21396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21397       };
21398     }
21399   }
21400
21401   jresult = SWIG_csharp_string_callback((&result)->c_str());
21402   return jresult;
21403 }
21404
21405
21406 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
21407   unsigned long jresult ;
21408   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21409   size_t result;
21410
21411   arg1 = (Dali::TypeInfo *)jarg1;
21412   {
21413     try {
21414       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
21415     } catch (std::out_of_range& e) {
21416       {
21417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21418       };
21419     } catch (std::exception& e) {
21420       {
21421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21422       };
21423     } catch (Dali::DaliException e) {
21424       {
21425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21426       };
21427     } catch (...) {
21428       {
21429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21430       };
21431     }
21432   }
21433
21434   jresult = (unsigned long)result;
21435   return jresult;
21436 }
21437
21438
21439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
21440   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21441   Dali::Property::IndexContainer *arg2 = 0 ;
21442
21443   arg1 = (Dali::TypeInfo *)jarg1;
21444   arg2 = (Dali::Property::IndexContainer *)jarg2;
21445   if (!arg2) {
21446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
21447     return ;
21448   }
21449   {
21450     try {
21451       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
21452     } catch (std::out_of_range& e) {
21453       {
21454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21455       };
21456     } catch (std::exception& e) {
21457       {
21458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21459       };
21460     } catch (Dali::DaliException e) {
21461       {
21462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21463       };
21464     } catch (...) {
21465       {
21466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21467       };
21468     }
21469   }
21470
21471 }
21472
21473
21474 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
21475   char * jresult ;
21476   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21477   Dali::Property::Index arg2 ;
21478   std::string *result = 0 ;
21479
21480   arg1 = (Dali::TypeInfo *)jarg1;
21481   arg2 = (Dali::Property::Index)jarg2;
21482   {
21483     try {
21484       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
21485     } catch (std::out_of_range& e) {
21486       {
21487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21488       };
21489     } catch (std::exception& e) {
21490       {
21491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21492       };
21493     } catch (Dali::DaliException e) {
21494       {
21495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21496       };
21497     } catch (...) {
21498       {
21499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21500       };
21501     }
21502   }
21503
21504   jresult = SWIG_csharp_string_callback(result->c_str());
21505   return jresult;
21506 }
21507
21508
21509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
21510   void * jresult ;
21511   Dali::TypeRegistry result;
21512
21513   {
21514     try {
21515       result = Dali::TypeRegistry::Get();
21516     } catch (std::out_of_range& e) {
21517       {
21518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21519       };
21520     } catch (std::exception& e) {
21521       {
21522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21523       };
21524     } catch (Dali::DaliException e) {
21525       {
21526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21527       };
21528     } catch (...) {
21529       {
21530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21531       };
21532     }
21533   }
21534
21535   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
21536   return jresult;
21537 }
21538
21539
21540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
21541   void * jresult ;
21542   Dali::TypeRegistry *result = 0 ;
21543
21544   {
21545     try {
21546       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
21547     } catch (std::out_of_range& e) {
21548       {
21549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21550       };
21551     } catch (std::exception& e) {
21552       {
21553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21554       };
21555     } catch (Dali::DaliException e) {
21556       {
21557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21558       };
21559     } catch (...) {
21560       {
21561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21562       };
21563     }
21564   }
21565
21566   jresult = (void *)result;
21567   return jresult;
21568 }
21569
21570
21571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
21572   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21573
21574   arg1 = (Dali::TypeRegistry *)jarg1;
21575   {
21576     try {
21577       delete arg1;
21578     } catch (std::out_of_range& e) {
21579       {
21580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21581       };
21582     } catch (std::exception& e) {
21583       {
21584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21585       };
21586     } catch (Dali::DaliException e) {
21587       {
21588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21589       };
21590     } catch (...) {
21591       {
21592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21593       };
21594     }
21595   }
21596
21597 }
21598
21599
21600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
21601   void * jresult ;
21602   Dali::TypeRegistry *arg1 = 0 ;
21603   Dali::TypeRegistry *result = 0 ;
21604
21605   arg1 = (Dali::TypeRegistry *)jarg1;
21606   if (!arg1) {
21607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21608     return 0;
21609   }
21610   {
21611     try {
21612       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
21613     } catch (std::out_of_range& e) {
21614       {
21615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21616       };
21617     } catch (std::exception& e) {
21618       {
21619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21620       };
21621     } catch (Dali::DaliException e) {
21622       {
21623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21624       };
21625     } catch (...) {
21626       {
21627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21628       };
21629     }
21630   }
21631
21632   jresult = (void *)result;
21633   return jresult;
21634 }
21635
21636
21637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
21638   void * jresult ;
21639   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21640   Dali::TypeRegistry *arg2 = 0 ;
21641   Dali::TypeRegistry *result = 0 ;
21642
21643   arg1 = (Dali::TypeRegistry *)jarg1;
21644   arg2 = (Dali::TypeRegistry *)jarg2;
21645   if (!arg2) {
21646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21647     return 0;
21648   }
21649   {
21650     try {
21651       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
21652     } catch (std::out_of_range& e) {
21653       {
21654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21655       };
21656     } catch (std::exception& e) {
21657       {
21658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21659       };
21660     } catch (Dali::DaliException e) {
21661       {
21662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21663       };
21664     } catch (...) {
21665       {
21666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21667       };
21668     }
21669   }
21670
21671   jresult = (void *)result;
21672   return jresult;
21673 }
21674
21675
21676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
21677   void * jresult ;
21678   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21679   std::string *arg2 = 0 ;
21680   Dali::TypeInfo result;
21681
21682   arg1 = (Dali::TypeRegistry *)jarg1;
21683   if (!jarg2) {
21684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21685     return 0;
21686   }
21687   std::string arg2_str(jarg2);
21688   arg2 = &arg2_str;
21689   {
21690     try {
21691       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
21692     } catch (std::out_of_range& e) {
21693       {
21694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21695       };
21696     } catch (std::exception& e) {
21697       {
21698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21699       };
21700     } catch (Dali::DaliException e) {
21701       {
21702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21703       };
21704     } catch (...) {
21705       {
21706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21707       };
21708     }
21709   }
21710
21711   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21712
21713   //argout typemap for const std::string&
21714
21715   return jresult;
21716 }
21717
21718
21719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
21720   void * jresult ;
21721   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21722   std::type_info *arg2 = 0 ;
21723   Dali::TypeInfo result;
21724
21725   arg1 = (Dali::TypeRegistry *)jarg1;
21726   arg2 = (std::type_info *)jarg2;
21727   if (!arg2) {
21728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21729     return 0;
21730   }
21731   {
21732     try {
21733       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
21734     } catch (std::out_of_range& e) {
21735       {
21736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21737       };
21738     } catch (std::exception& e) {
21739       {
21740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21741       };
21742     } catch (Dali::DaliException e) {
21743       {
21744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21745       };
21746     } catch (...) {
21747       {
21748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21749       };
21750     }
21751   }
21752
21753   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21754   return jresult;
21755 }
21756
21757
21758 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
21759   unsigned long jresult ;
21760   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21761   size_t result;
21762
21763   arg1 = (Dali::TypeRegistry *)jarg1;
21764   {
21765     try {
21766       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
21767     } catch (std::out_of_range& e) {
21768       {
21769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21770       };
21771     } catch (std::exception& e) {
21772       {
21773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21774       };
21775     } catch (Dali::DaliException e) {
21776       {
21777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21778       };
21779     } catch (...) {
21780       {
21781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21782       };
21783     }
21784   }
21785
21786   jresult = (unsigned long)result;
21787   return jresult;
21788 }
21789
21790
21791 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
21792   char * jresult ;
21793   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21794   size_t arg2 ;
21795   std::string result;
21796
21797   arg1 = (Dali::TypeRegistry *)jarg1;
21798   arg2 = (size_t)jarg2;
21799   {
21800     try {
21801       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
21802     } catch (std::out_of_range& e) {
21803       {
21804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21805       };
21806     } catch (std::exception& e) {
21807       {
21808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21809       };
21810     } catch (Dali::DaliException e) {
21811       {
21812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21813       };
21814     } catch (...) {
21815       {
21816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21817       };
21818     }
21819   }
21820
21821   jresult = SWIG_csharp_string_callback((&result)->c_str());
21822   return jresult;
21823 }
21824
21825
21826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_2(void * jarg1) {
21827   void * jresult ;
21828   Dali::Internal::TypeRegistry *arg1 = (Dali::Internal::TypeRegistry *) 0 ;
21829   Dali::TypeRegistry *result = 0 ;
21830
21831   arg1 = (Dali::Internal::TypeRegistry *)jarg1;
21832   {
21833     try {
21834       result = (Dali::TypeRegistry *)new Dali::TypeRegistry(arg1);
21835     } catch (std::out_of_range& e) {
21836       {
21837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21838       };
21839     } catch (std::exception& e) {
21840       {
21841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21842       };
21843     } catch (Dali::DaliException e) {
21844       {
21845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21846       };
21847     } catch (...) {
21848       {
21849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21850       };
21851     }
21852   }
21853
21854   jresult = (void *)result;
21855   return jresult;
21856 }
21857
21858
21859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
21860   void * jresult ;
21861   std::type_info *arg1 = 0 ;
21862   std::type_info *arg2 = 0 ;
21863   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
21864   Dali::TypeRegistration *result = 0 ;
21865
21866   arg1 = (std::type_info *)jarg1;
21867   if (!arg1) {
21868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21869     return 0;
21870   }
21871   arg2 = (std::type_info *)jarg2;
21872   if (!arg2) {
21873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21874     return 0;
21875   }
21876   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
21877   {
21878     try {
21879       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
21880     } catch (std::out_of_range& e) {
21881       {
21882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21883       };
21884     } catch (std::exception& e) {
21885       {
21886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21887       };
21888     } catch (Dali::DaliException e) {
21889       {
21890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21891       };
21892     } catch (...) {
21893       {
21894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21895       };
21896     }
21897   }
21898
21899   jresult = (void *)result;
21900   return jresult;
21901 }
21902
21903
21904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
21905   void * jresult ;
21906   std::type_info *arg1 = 0 ;
21907   std::type_info *arg2 = 0 ;
21908   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
21909   bool arg4 ;
21910   Dali::TypeRegistration *result = 0 ;
21911
21912   arg1 = (std::type_info *)jarg1;
21913   if (!arg1) {
21914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21915     return 0;
21916   }
21917   arg2 = (std::type_info *)jarg2;
21918   if (!arg2) {
21919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21920     return 0;
21921   }
21922   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
21923   arg4 = jarg4 ? true : false;
21924   {
21925     try {
21926       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
21927     } catch (std::out_of_range& e) {
21928       {
21929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21930       };
21931     } catch (std::exception& e) {
21932       {
21933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21934       };
21935     } catch (Dali::DaliException e) {
21936       {
21937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21938       };
21939     } catch (...) {
21940       {
21941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21942       };
21943     }
21944   }
21945
21946   jresult = (void *)result;
21947   return jresult;
21948 }
21949
21950
21951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
21952   void * jresult ;
21953   std::string *arg1 = 0 ;
21954   std::type_info *arg2 = 0 ;
21955   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
21956   Dali::TypeRegistration *result = 0 ;
21957
21958   if (!jarg1) {
21959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21960     return 0;
21961   }
21962   std::string arg1_str(jarg1);
21963   arg1 = &arg1_str;
21964   arg2 = (std::type_info *)jarg2;
21965   if (!arg2) {
21966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21967     return 0;
21968   }
21969   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
21970   {
21971     try {
21972       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
21973     } catch (std::out_of_range& e) {
21974       {
21975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21976       };
21977     } catch (std::exception& e) {
21978       {
21979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21980       };
21981     } catch (Dali::DaliException e) {
21982       {
21983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21984       };
21985     } catch (...) {
21986       {
21987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21988       };
21989     }
21990   }
21991
21992   jresult = (void *)result;
21993
21994   //argout typemap for const std::string&
21995
21996   return jresult;
21997 }
21998
21999
22000 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
22001   char * jresult ;
22002   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22003   std::string result;
22004
22005   arg1 = (Dali::TypeRegistration *)jarg1;
22006   {
22007     try {
22008       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
22009     } catch (std::out_of_range& e) {
22010       {
22011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22012       };
22013     } catch (std::exception& e) {
22014       {
22015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22016       };
22017     } catch (Dali::DaliException e) {
22018       {
22019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22020       };
22021     } catch (...) {
22022       {
22023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22024       };
22025     }
22026   }
22027
22028   jresult = SWIG_csharp_string_callback((&result)->c_str());
22029   return jresult;
22030 }
22031
22032
22033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
22034   std::string *arg1 = 0 ;
22035   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22036
22037   if (!jarg1) {
22038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22039     return ;
22040   }
22041   std::string arg1_str(jarg1);
22042   arg1 = &arg1_str;
22043   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
22044   {
22045     try {
22046       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
22047     } catch (std::out_of_range& e) {
22048       {
22049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22050       };
22051     } catch (std::exception& e) {
22052       {
22053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22054       };
22055     } catch (Dali::DaliException e) {
22056       {
22057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22058       };
22059     } catch (...) {
22060       {
22061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22062       };
22063     }
22064   }
22065
22066
22067   //argout typemap for const std::string&
22068
22069 }
22070
22071
22072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22073   std::string *arg1 = 0 ;
22074   std::string *arg2 = 0 ;
22075   int arg3 ;
22076   Dali::Property::Type arg4 ;
22077   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22078   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22079
22080   if (!jarg1) {
22081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22082     return ;
22083   }
22084   std::string arg1_str(jarg1);
22085   arg1 = &arg1_str;
22086   if (!jarg2) {
22087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22088     return ;
22089   }
22090   std::string arg2_str(jarg2);
22091   arg2 = &arg2_str;
22092   arg3 = (int)jarg3;
22093   arg4 = (Dali::Property::Type)jarg4;
22094   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22095   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22096   {
22097     try {
22098       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22099     } catch (std::out_of_range& e) {
22100       {
22101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22102       };
22103     } catch (std::exception& e) {
22104       {
22105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22106       };
22107     } catch (Dali::DaliException e) {
22108       {
22109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22110       };
22111     } catch (...) {
22112       {
22113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22114       };
22115     }
22116   }
22117
22118
22119   //argout typemap for const std::string&
22120
22121
22122   //argout typemap for const std::string&
22123
22124 }
22125
22126
22127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
22128   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22129
22130   arg1 = (Dali::TypeRegistration *)jarg1;
22131   {
22132     try {
22133       delete arg1;
22134     } catch (std::out_of_range& e) {
22135       {
22136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22137       };
22138     } catch (std::exception& e) {
22139       {
22140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22141       };
22142     } catch (Dali::DaliException e) {
22143       {
22144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22145       };
22146     } catch (...) {
22147       {
22148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22149       };
22150     }
22151   }
22152
22153 }
22154
22155
22156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
22157   void * jresult ;
22158   Dali::TypeRegistration *arg1 = 0 ;
22159   std::string *arg2 = 0 ;
22160   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
22161   Dali::SignalConnectorType *result = 0 ;
22162
22163   arg1 = (Dali::TypeRegistration *)jarg1;
22164   if (!arg1) {
22165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22166     return 0;
22167   }
22168   if (!jarg2) {
22169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22170     return 0;
22171   }
22172   std::string arg2_str(jarg2);
22173   arg2 = &arg2_str;
22174   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
22175   {
22176     try {
22177       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
22178     } catch (std::out_of_range& e) {
22179       {
22180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22181       };
22182     } catch (std::exception& e) {
22183       {
22184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22185       };
22186     } catch (Dali::DaliException e) {
22187       {
22188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22189       };
22190     } catch (...) {
22191       {
22192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22193       };
22194     }
22195   }
22196
22197   jresult = (void *)result;
22198
22199   //argout typemap for const std::string&
22200
22201   return jresult;
22202 }
22203
22204
22205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
22206   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
22207
22208   arg1 = (Dali::SignalConnectorType *)jarg1;
22209   {
22210     try {
22211       delete arg1;
22212     } catch (std::out_of_range& e) {
22213       {
22214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22215       };
22216     } catch (std::exception& e) {
22217       {
22218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22219       };
22220     } catch (Dali::DaliException e) {
22221       {
22222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22223       };
22224     } catch (...) {
22225       {
22226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22227       };
22228     }
22229   }
22230
22231 }
22232
22233
22234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
22235   void * jresult ;
22236   Dali::TypeRegistration *arg1 = 0 ;
22237   std::string *arg2 = 0 ;
22238   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
22239   Dali::TypeAction *result = 0 ;
22240
22241   arg1 = (Dali::TypeRegistration *)jarg1;
22242   if (!arg1) {
22243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22244     return 0;
22245   }
22246   if (!jarg2) {
22247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22248     return 0;
22249   }
22250   std::string arg2_str(jarg2);
22251   arg2 = &arg2_str;
22252   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
22253   {
22254     try {
22255       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
22256     } catch (std::out_of_range& e) {
22257       {
22258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22259       };
22260     } catch (std::exception& e) {
22261       {
22262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22263       };
22264     } catch (Dali::DaliException e) {
22265       {
22266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22267       };
22268     } catch (...) {
22269       {
22270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22271       };
22272     }
22273   }
22274
22275   jresult = (void *)result;
22276
22277   //argout typemap for const std::string&
22278
22279   return jresult;
22280 }
22281
22282
22283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
22284   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
22285
22286   arg1 = (Dali::TypeAction *)jarg1;
22287   {
22288     try {
22289       delete arg1;
22290     } catch (std::out_of_range& e) {
22291       {
22292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22293       };
22294     } catch (std::exception& e) {
22295       {
22296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22297       };
22298     } catch (Dali::DaliException e) {
22299       {
22300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22301       };
22302     } catch (...) {
22303       {
22304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22305       };
22306     }
22307   }
22308
22309 }
22310
22311
22312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22313   void * jresult ;
22314   Dali::TypeRegistration *arg1 = 0 ;
22315   std::string *arg2 = 0 ;
22316   Dali::Property::Index arg3 ;
22317   Dali::Property::Type arg4 ;
22318   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
22319   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
22320   Dali::PropertyRegistration *result = 0 ;
22321
22322   arg1 = (Dali::TypeRegistration *)jarg1;
22323   if (!arg1) {
22324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22325     return 0;
22326   }
22327   if (!jarg2) {
22328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22329     return 0;
22330   }
22331   std::string arg2_str(jarg2);
22332   arg2 = &arg2_str;
22333   arg3 = (Dali::Property::Index)jarg3;
22334   arg4 = (Dali::Property::Type)jarg4;
22335   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
22336   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
22337   {
22338     try {
22339       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22340     } catch (std::out_of_range& e) {
22341       {
22342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22343       };
22344     } catch (std::exception& e) {
22345       {
22346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22347       };
22348     } catch (Dali::DaliException e) {
22349       {
22350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22351       };
22352     } catch (...) {
22353       {
22354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22355       };
22356     }
22357   }
22358
22359   jresult = (void *)result;
22360
22361   //argout typemap for const std::string&
22362
22363   return jresult;
22364 }
22365
22366
22367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
22368   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
22369
22370   arg1 = (Dali::PropertyRegistration *)jarg1;
22371   {
22372     try {
22373       delete arg1;
22374     } catch (std::out_of_range& e) {
22375       {
22376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22377       };
22378     } catch (std::exception& e) {
22379       {
22380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22381       };
22382     } catch (Dali::DaliException e) {
22383       {
22384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22385       };
22386     } catch (...) {
22387       {
22388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22389       };
22390     }
22391   }
22392
22393 }
22394
22395
22396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22397   void * jresult ;
22398   Dali::TypeRegistration *arg1 = 0 ;
22399   std::string *arg2 = 0 ;
22400   Dali::Property::Index arg3 ;
22401   Dali::Property::Type arg4 ;
22402   Dali::AnimatablePropertyRegistration *result = 0 ;
22403
22404   arg1 = (Dali::TypeRegistration *)jarg1;
22405   if (!arg1) {
22406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22407     return 0;
22408   }
22409   if (!jarg2) {
22410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22411     return 0;
22412   }
22413   std::string arg2_str(jarg2);
22414   arg2 = &arg2_str;
22415   arg3 = (Dali::Property::Index)jarg3;
22416   arg4 = (Dali::Property::Type)jarg4;
22417   {
22418     try {
22419       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22420     } catch (std::out_of_range& e) {
22421       {
22422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22423       };
22424     } catch (std::exception& e) {
22425       {
22426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22427       };
22428     } catch (Dali::DaliException e) {
22429       {
22430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22431       };
22432     } catch (...) {
22433       {
22434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22435       };
22436     }
22437   }
22438
22439   jresult = (void *)result;
22440
22441   //argout typemap for const std::string&
22442
22443   return jresult;
22444 }
22445
22446
22447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
22448   void * jresult ;
22449   Dali::TypeRegistration *arg1 = 0 ;
22450   std::string *arg2 = 0 ;
22451   Dali::Property::Index arg3 ;
22452   Dali::Property::Value *arg4 = 0 ;
22453   Dali::AnimatablePropertyRegistration *result = 0 ;
22454
22455   arg1 = (Dali::TypeRegistration *)jarg1;
22456   if (!arg1) {
22457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22458     return 0;
22459   }
22460   if (!jarg2) {
22461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22462     return 0;
22463   }
22464   std::string arg2_str(jarg2);
22465   arg2 = &arg2_str;
22466   arg3 = (Dali::Property::Index)jarg3;
22467   arg4 = (Dali::Property::Value *)jarg4;
22468   if (!arg4) {
22469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
22470     return 0;
22471   }
22472   {
22473     try {
22474       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
22475     } catch (std::out_of_range& e) {
22476       {
22477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22478       };
22479     } catch (std::exception& e) {
22480       {
22481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22482       };
22483     } catch (Dali::DaliException e) {
22484       {
22485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22486       };
22487     } catch (...) {
22488       {
22489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22490       };
22491     }
22492   }
22493
22494   jresult = (void *)result;
22495
22496   //argout typemap for const std::string&
22497
22498   return jresult;
22499 }
22500
22501
22502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
22503   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
22504
22505   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
22506   {
22507     try {
22508       delete arg1;
22509     } catch (std::out_of_range& e) {
22510       {
22511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22512       };
22513     } catch (std::exception& e) {
22514       {
22515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22516       };
22517     } catch (Dali::DaliException e) {
22518       {
22519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22520       };
22521     } catch (...) {
22522       {
22523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22524       };
22525     }
22526   }
22527
22528 }
22529
22530
22531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
22532   void * jresult ;
22533   Dali::TypeRegistration *arg1 = 0 ;
22534   std::string *arg2 = 0 ;
22535   Dali::Property::Index arg3 ;
22536   Dali::Property::Index arg4 ;
22537   unsigned int arg5 ;
22538   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
22539
22540   arg1 = (Dali::TypeRegistration *)jarg1;
22541   if (!arg1) {
22542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22543     return 0;
22544   }
22545   if (!jarg2) {
22546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22547     return 0;
22548   }
22549   std::string arg2_str(jarg2);
22550   arg2 = &arg2_str;
22551   arg3 = (Dali::Property::Index)jarg3;
22552   arg4 = (Dali::Property::Index)jarg4;
22553   arg5 = (unsigned int)jarg5;
22554   {
22555     try {
22556       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
22557     } catch (std::out_of_range& e) {
22558       {
22559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22560       };
22561     } catch (std::exception& e) {
22562       {
22563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22564       };
22565     } catch (Dali::DaliException e) {
22566       {
22567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22568       };
22569     } catch (...) {
22570       {
22571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22572       };
22573     }
22574   }
22575
22576   jresult = (void *)result;
22577
22578   //argout typemap for const std::string&
22579
22580   return jresult;
22581 }
22582
22583
22584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
22585   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
22586
22587   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
22588   {
22589     try {
22590       delete arg1;
22591     } catch (std::out_of_range& e) {
22592       {
22593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22594       };
22595     } catch (std::exception& e) {
22596       {
22597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22598       };
22599     } catch (Dali::DaliException e) {
22600       {
22601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22602       };
22603     } catch (...) {
22604       {
22605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22606       };
22607     }
22608   }
22609
22610 }
22611
22612
22613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22614   void * jresult ;
22615   Dali::TypeRegistration *arg1 = 0 ;
22616   std::string *arg2 = 0 ;
22617   Dali::Property::Index arg3 ;
22618   Dali::Property::Type arg4 ;
22619   Dali::ChildPropertyRegistration *result = 0 ;
22620
22621   arg1 = (Dali::TypeRegistration *)jarg1;
22622   if (!arg1) {
22623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22624     return 0;
22625   }
22626   if (!jarg2) {
22627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22628     return 0;
22629   }
22630   std::string arg2_str(jarg2);
22631   arg2 = &arg2_str;
22632   arg3 = (Dali::Property::Index)jarg3;
22633   arg4 = (Dali::Property::Type)jarg4;
22634   {
22635     try {
22636       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22637     } catch (std::out_of_range& e) {
22638       {
22639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22640       };
22641     } catch (std::exception& e) {
22642       {
22643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22644       };
22645     } catch (Dali::DaliException e) {
22646       {
22647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22648       };
22649     } catch (...) {
22650       {
22651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22652       };
22653     }
22654   }
22655
22656   jresult = (void *)result;
22657
22658   //argout typemap for const std::string&
22659
22660   return jresult;
22661 }
22662
22663
22664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
22665   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
22666
22667   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
22668   {
22669     try {
22670       delete arg1;
22671     } catch (std::out_of_range& e) {
22672       {
22673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22674       };
22675     } catch (std::exception& e) {
22676       {
22677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22678       };
22679     } catch (Dali::DaliException e) {
22680       {
22681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22682       };
22683     } catch (...) {
22684       {
22685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22686       };
22687     }
22688   }
22689
22690 }
22691
22692
22693 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
22694   unsigned int jresult ;
22695   std::string *arg1 = 0 ;
22696   std::type_info *arg2 = 0 ;
22697   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22698   bool result;
22699
22700   if (!jarg1) {
22701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22702     return 0;
22703   }
22704   std::string arg1_str(jarg1);
22705   arg1 = &arg1_str;
22706   arg2 = (std::type_info *)jarg2;
22707   if (!arg2) {
22708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22709     return 0;
22710   }
22711   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
22712   {
22713     try {
22714       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22715     } catch (std::out_of_range& e) {
22716       {
22717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22718       };
22719     } catch (std::exception& e) {
22720       {
22721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22722       };
22723     } catch (Dali::DaliException e) {
22724       {
22725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22726       };
22727     } catch (...) {
22728       {
22729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22730       };
22731     }
22732   }
22733
22734   jresult = result;
22735
22736   //argout typemap for const std::string&
22737
22738   return jresult;
22739 }
22740
22741
22742 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22743   unsigned int jresult ;
22744   std::string *arg1 = 0 ;
22745   std::string *arg2 = 0 ;
22746   Dali::Property::Index arg3 ;
22747   Dali::Property::Type arg4 ;
22748   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22749   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22750   bool result;
22751
22752   if (!jarg1) {
22753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22754     return 0;
22755   }
22756   std::string arg1_str(jarg1);
22757   arg1 = &arg1_str;
22758   if (!jarg2) {
22759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22760     return 0;
22761   }
22762   std::string arg2_str(jarg2);
22763   arg2 = &arg2_str;
22764   arg3 = (Dali::Property::Index)jarg3;
22765   arg4 = (Dali::Property::Type)jarg4;
22766   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22767   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22768   {
22769     try {
22770       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22771     } catch (std::out_of_range& e) {
22772       {
22773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22774       };
22775     } catch (std::exception& e) {
22776       {
22777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22778       };
22779     } catch (Dali::DaliException e) {
22780       {
22781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22782       };
22783     } catch (...) {
22784       {
22785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22786       };
22787     }
22788   }
22789
22790   jresult = result;
22791
22792   //argout typemap for const std::string&
22793
22794
22795   //argout typemap for const std::string&
22796
22797   return jresult;
22798 }
22799
22800
22801 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
22802   float jresult ;
22803   float result;
22804
22805   result = (float)(float)Dali::ParentOrigin::TOP;
22806   jresult = result;
22807   return jresult;
22808 }
22809
22810
22811 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
22812   float jresult ;
22813   float result;
22814
22815   result = (float)(float)Dali::ParentOrigin::BOTTOM;
22816   jresult = result;
22817   return jresult;
22818 }
22819
22820
22821 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
22822   float jresult ;
22823   float result;
22824
22825   result = (float)(float)Dali::ParentOrigin::LEFT;
22826   jresult = result;
22827   return jresult;
22828 }
22829
22830
22831 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
22832   float jresult ;
22833   float result;
22834
22835   result = (float)(float)Dali::ParentOrigin::RIGHT;
22836   jresult = result;
22837   return jresult;
22838 }
22839
22840
22841 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
22842   float jresult ;
22843   float result;
22844
22845   result = (float)(float)Dali::ParentOrigin::MIDDLE;
22846   jresult = result;
22847   return jresult;
22848 }
22849
22850
22851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
22852   void * jresult ;
22853   Dali::Vector3 *result = 0 ;
22854
22855   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
22856   jresult = (void *)result;
22857   return jresult;
22858 }
22859
22860
22861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
22862   void * jresult ;
22863   Dali::Vector3 *result = 0 ;
22864
22865   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
22866   jresult = (void *)result;
22867   return jresult;
22868 }
22869
22870
22871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
22872   void * jresult ;
22873   Dali::Vector3 *result = 0 ;
22874
22875   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
22876   jresult = (void *)result;
22877   return jresult;
22878 }
22879
22880
22881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
22882   void * jresult ;
22883   Dali::Vector3 *result = 0 ;
22884
22885   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
22886   jresult = (void *)result;
22887   return jresult;
22888 }
22889
22890
22891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
22892   void * jresult ;
22893   Dali::Vector3 *result = 0 ;
22894
22895   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
22896   jresult = (void *)result;
22897   return jresult;
22898 }
22899
22900
22901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
22902   void * jresult ;
22903   Dali::Vector3 *result = 0 ;
22904
22905   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
22906   jresult = (void *)result;
22907   return jresult;
22908 }
22909
22910
22911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
22912   void * jresult ;
22913   Dali::Vector3 *result = 0 ;
22914
22915   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
22916   jresult = (void *)result;
22917   return jresult;
22918 }
22919
22920
22921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
22922   void * jresult ;
22923   Dali::Vector3 *result = 0 ;
22924
22925   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
22926   jresult = (void *)result;
22927   return jresult;
22928 }
22929
22930
22931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
22932   void * jresult ;
22933   Dali::Vector3 *result = 0 ;
22934
22935   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
22936   jresult = (void *)result;
22937   return jresult;
22938 }
22939
22940
22941 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
22942   float jresult ;
22943   float result;
22944
22945   result = (float)(float)Dali::AnchorPoint::TOP;
22946   jresult = result;
22947   return jresult;
22948 }
22949
22950
22951 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
22952   float jresult ;
22953   float result;
22954
22955   result = (float)(float)Dali::AnchorPoint::BOTTOM;
22956   jresult = result;
22957   return jresult;
22958 }
22959
22960
22961 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
22962   float jresult ;
22963   float result;
22964
22965   result = (float)(float)Dali::AnchorPoint::LEFT;
22966   jresult = result;
22967   return jresult;
22968 }
22969
22970
22971 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
22972   float jresult ;
22973   float result;
22974
22975   result = (float)(float)Dali::AnchorPoint::RIGHT;
22976   jresult = result;
22977   return jresult;
22978 }
22979
22980
22981 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
22982   float jresult ;
22983   float result;
22984
22985   result = (float)(float)Dali::AnchorPoint::MIDDLE;
22986   jresult = result;
22987   return jresult;
22988 }
22989
22990
22991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
22992   void * jresult ;
22993   Dali::Vector3 *result = 0 ;
22994
22995   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
22996   jresult = (void *)result;
22997   return jresult;
22998 }
22999
23000
23001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
23002   void * jresult ;
23003   Dali::Vector3 *result = 0 ;
23004
23005   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
23006   jresult = (void *)result;
23007   return jresult;
23008 }
23009
23010
23011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
23012   void * jresult ;
23013   Dali::Vector3 *result = 0 ;
23014
23015   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
23016   jresult = (void *)result;
23017   return jresult;
23018 }
23019
23020
23021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
23022   void * jresult ;
23023   Dali::Vector3 *result = 0 ;
23024
23025   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
23026   jresult = (void *)result;
23027   return jresult;
23028 }
23029
23030
23031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
23032   void * jresult ;
23033   Dali::Vector3 *result = 0 ;
23034
23035   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
23036   jresult = (void *)result;
23037   return jresult;
23038 }
23039
23040
23041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
23042   void * jresult ;
23043   Dali::Vector3 *result = 0 ;
23044
23045   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
23046   jresult = (void *)result;
23047   return jresult;
23048 }
23049
23050
23051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
23052   void * jresult ;
23053   Dali::Vector3 *result = 0 ;
23054
23055   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
23056   jresult = (void *)result;
23057   return jresult;
23058 }
23059
23060
23061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
23062   void * jresult ;
23063   Dali::Vector3 *result = 0 ;
23064
23065   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
23066   jresult = (void *)result;
23067   return jresult;
23068 }
23069
23070
23071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
23072   void * jresult ;
23073   Dali::Vector3 *result = 0 ;
23074
23075   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
23076   jresult = (void *)result;
23077   return jresult;
23078 }
23079
23080
23081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
23082   void * jresult ;
23083   Dali::Vector4 *result = 0 ;
23084
23085   result = (Dali::Vector4 *)&Dali::Color::BLACK;
23086   jresult = (void *)result;
23087   return jresult;
23088 }
23089
23090
23091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
23092   void * jresult ;
23093   Dali::Vector4 *result = 0 ;
23094
23095   result = (Dali::Vector4 *)&Dali::Color::WHITE;
23096   jresult = (void *)result;
23097   return jresult;
23098 }
23099
23100
23101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
23102   void * jresult ;
23103   Dali::Vector4 *result = 0 ;
23104
23105   result = (Dali::Vector4 *)&Dali::Color::RED;
23106   jresult = (void *)result;
23107   return jresult;
23108 }
23109
23110
23111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
23112   void * jresult ;
23113   Dali::Vector4 *result = 0 ;
23114
23115   result = (Dali::Vector4 *)&Dali::Color::GREEN;
23116   jresult = (void *)result;
23117   return jresult;
23118 }
23119
23120
23121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
23122   void * jresult ;
23123   Dali::Vector4 *result = 0 ;
23124
23125   result = (Dali::Vector4 *)&Dali::Color::BLUE;
23126   jresult = (void *)result;
23127   return jresult;
23128 }
23129
23130
23131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
23132   void * jresult ;
23133   Dali::Vector4 *result = 0 ;
23134
23135   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
23136   jresult = (void *)result;
23137   return jresult;
23138 }
23139
23140
23141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
23142   void * jresult ;
23143   Dali::Vector4 *result = 0 ;
23144
23145   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
23146   jresult = (void *)result;
23147   return jresult;
23148 }
23149
23150
23151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
23152   void * jresult ;
23153   Dali::Vector4 *result = 0 ;
23154
23155   result = (Dali::Vector4 *)&Dali::Color::CYAN;
23156   jresult = (void *)result;
23157   return jresult;
23158 }
23159
23160
23161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
23162   void * jresult ;
23163   Dali::Vector4 *result = 0 ;
23164
23165   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
23166   jresult = (void *)result;
23167   return jresult;
23168 }
23169
23170
23171 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
23172   float jresult ;
23173   float result;
23174
23175   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
23176   jresult = result;
23177   return jresult;
23178 }
23179
23180
23181 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
23182   float jresult ;
23183   float result;
23184
23185   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
23186   jresult = result;
23187   return jresult;
23188 }
23189
23190
23191 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
23192   float jresult ;
23193   float result;
23194
23195   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
23196   jresult = result;
23197   return jresult;
23198 }
23199
23200
23201 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
23202   float jresult ;
23203   float result;
23204
23205   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
23206   jresult = result;
23207   return jresult;
23208 }
23209
23210
23211 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
23212   float jresult ;
23213   float result;
23214
23215   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
23216   jresult = result;
23217   return jresult;
23218 }
23219
23220
23221 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
23222   float jresult ;
23223   float result;
23224
23225   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
23226   jresult = result;
23227   return jresult;
23228 }
23229
23230
23231 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
23232   float jresult ;
23233   float result;
23234
23235   result = (float)(float)Dali::Math::PI;
23236   jresult = result;
23237   return jresult;
23238 }
23239
23240
23241 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
23242   float jresult ;
23243   float result;
23244
23245   result = (float)(float)Dali::Math::PI_2;
23246   jresult = result;
23247   return jresult;
23248 }
23249
23250
23251 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
23252   float jresult ;
23253   float result;
23254
23255   result = (float)(float)Dali::Math::PI_4;
23256   jresult = result;
23257   return jresult;
23258 }
23259
23260
23261 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
23262   float jresult ;
23263   float result;
23264
23265   result = (float)(float)Dali::Math::PI_OVER_180;
23266   jresult = result;
23267   return jresult;
23268 }
23269
23270
23271 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
23272   float jresult ;
23273   float result;
23274
23275   result = (float)(float)Dali::Math::ONE80_OVER_PI;
23276   jresult = result;
23277   return jresult;
23278 }
23279
23280
23281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
23282   int jresult ;
23283   Dali::ResizePolicy::Type result;
23284
23285   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
23286   jresult = (int)result;
23287   return jresult;
23288 }
23289
23290
23291 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
23292   unsigned long jresult ;
23293   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23294   Dali::VectorBase::SizeType result;
23295
23296   arg1 = (Dali::VectorBase *)jarg1;
23297   {
23298     try {
23299       result = ((Dali::VectorBase const *)arg1)->Count();
23300     } catch (std::out_of_range& e) {
23301       {
23302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23303       };
23304     } catch (std::exception& e) {
23305       {
23306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23307       };
23308     } catch (Dali::DaliException e) {
23309       {
23310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23311       };
23312     } catch (...) {
23313       {
23314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23315       };
23316     }
23317   }
23318
23319   jresult = (unsigned long)result;
23320   return jresult;
23321 }
23322
23323
23324 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
23325   unsigned long jresult ;
23326   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23327   Dali::VectorBase::SizeType result;
23328
23329   arg1 = (Dali::VectorBase *)jarg1;
23330   {
23331     try {
23332       result = ((Dali::VectorBase const *)arg1)->Size();
23333     } catch (std::out_of_range& e) {
23334       {
23335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23336       };
23337     } catch (std::exception& e) {
23338       {
23339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23340       };
23341     } catch (Dali::DaliException e) {
23342       {
23343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23344       };
23345     } catch (...) {
23346       {
23347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23348       };
23349     }
23350   }
23351
23352   jresult = (unsigned long)result;
23353   return jresult;
23354 }
23355
23356
23357 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
23358   unsigned int jresult ;
23359   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23360   bool result;
23361
23362   arg1 = (Dali::VectorBase *)jarg1;
23363   {
23364     try {
23365       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
23366     } catch (std::out_of_range& e) {
23367       {
23368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23369       };
23370     } catch (std::exception& e) {
23371       {
23372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23373       };
23374     } catch (Dali::DaliException e) {
23375       {
23376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23377       };
23378     } catch (...) {
23379       {
23380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23381       };
23382     }
23383   }
23384
23385   jresult = result;
23386   return jresult;
23387 }
23388
23389
23390 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
23391   unsigned long jresult ;
23392   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23393   Dali::VectorBase::SizeType result;
23394
23395   arg1 = (Dali::VectorBase *)jarg1;
23396   {
23397     try {
23398       result = ((Dali::VectorBase const *)arg1)->Capacity();
23399     } catch (std::out_of_range& e) {
23400       {
23401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23402       };
23403     } catch (std::exception& e) {
23404       {
23405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23406       };
23407     } catch (Dali::DaliException e) {
23408       {
23409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23410       };
23411     } catch (...) {
23412       {
23413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23414       };
23415     }
23416   }
23417
23418   jresult = (unsigned long)result;
23419   return jresult;
23420 }
23421
23422
23423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
23424   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23425
23426   arg1 = (Dali::VectorBase *)jarg1;
23427   {
23428     try {
23429       (arg1)->Release();
23430     } catch (std::out_of_range& e) {
23431       {
23432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23433       };
23434     } catch (std::exception& e) {
23435       {
23436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23437       };
23438     } catch (Dali::DaliException e) {
23439       {
23440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23441       };
23442     } catch (...) {
23443       {
23444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23445       };
23446     }
23447   }
23448
23449 }
23450
23451
23452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
23453   void * jresult ;
23454   Dali::Image *result = 0 ;
23455
23456   {
23457     try {
23458       result = (Dali::Image *)new Dali::Image();
23459     } catch (std::out_of_range& e) {
23460       {
23461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23462       };
23463     } catch (std::exception& e) {
23464       {
23465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23466       };
23467     } catch (Dali::DaliException e) {
23468       {
23469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23470       };
23471     } catch (...) {
23472       {
23473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23474       };
23475     }
23476   }
23477
23478   jresult = (void *)result;
23479   return jresult;
23480 }
23481
23482
23483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
23484   Dali::Image *arg1 = (Dali::Image *) 0 ;
23485
23486   arg1 = (Dali::Image *)jarg1;
23487   {
23488     try {
23489       delete arg1;
23490     } catch (std::out_of_range& e) {
23491       {
23492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23493       };
23494     } catch (std::exception& e) {
23495       {
23496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23497       };
23498     } catch (Dali::DaliException e) {
23499       {
23500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23501       };
23502     } catch (...) {
23503       {
23504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23505       };
23506     }
23507   }
23508
23509 }
23510
23511
23512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
23513   void * jresult ;
23514   Dali::Image *arg1 = 0 ;
23515   Dali::Image *result = 0 ;
23516
23517   arg1 = (Dali::Image *)jarg1;
23518   if (!arg1) {
23519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23520     return 0;
23521   }
23522   {
23523     try {
23524       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
23525     } catch (std::out_of_range& e) {
23526       {
23527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23528       };
23529     } catch (std::exception& e) {
23530       {
23531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23532       };
23533     } catch (Dali::DaliException e) {
23534       {
23535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23536       };
23537     } catch (...) {
23538       {
23539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23540       };
23541     }
23542   }
23543
23544   jresult = (void *)result;
23545   return jresult;
23546 }
23547
23548
23549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
23550   void * jresult ;
23551   Dali::Image *arg1 = (Dali::Image *) 0 ;
23552   Dali::Image *arg2 = 0 ;
23553   Dali::Image *result = 0 ;
23554
23555   arg1 = (Dali::Image *)jarg1;
23556   arg2 = (Dali::Image *)jarg2;
23557   if (!arg2) {
23558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23559     return 0;
23560   }
23561   {
23562     try {
23563       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
23564     } catch (std::out_of_range& e) {
23565       {
23566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23567       };
23568     } catch (std::exception& e) {
23569       {
23570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23571       };
23572     } catch (Dali::DaliException e) {
23573       {
23574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23575       };
23576     } catch (...) {
23577       {
23578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23579       };
23580     }
23581   }
23582
23583   jresult = (void *)result;
23584   return jresult;
23585 }
23586
23587
23588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
23589   void * jresult ;
23590   Dali::BaseHandle arg1 ;
23591   Dali::BaseHandle *argp1 ;
23592   Dali::Image result;
23593
23594   argp1 = (Dali::BaseHandle *)jarg1;
23595   if (!argp1) {
23596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23597     return 0;
23598   }
23599   arg1 = *argp1;
23600   {
23601     try {
23602       result = Dali::Image::DownCast(arg1);
23603     } catch (std::out_of_range& e) {
23604       {
23605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23606       };
23607     } catch (std::exception& e) {
23608       {
23609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23610       };
23611     } catch (Dali::DaliException e) {
23612       {
23613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23614       };
23615     } catch (...) {
23616       {
23617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23618       };
23619     }
23620   }
23621
23622   jresult = new Dali::Image((const Dali::Image &)result);
23623   return jresult;
23624 }
23625
23626
23627 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
23628   unsigned int jresult ;
23629   Dali::Image *arg1 = (Dali::Image *) 0 ;
23630   unsigned int result;
23631
23632   arg1 = (Dali::Image *)jarg1;
23633   {
23634     try {
23635       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
23636     } catch (std::out_of_range& e) {
23637       {
23638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23639       };
23640     } catch (std::exception& e) {
23641       {
23642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23643       };
23644     } catch (Dali::DaliException e) {
23645       {
23646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23647       };
23648     } catch (...) {
23649       {
23650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23651       };
23652     }
23653   }
23654
23655   jresult = result;
23656   return jresult;
23657 }
23658
23659
23660 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
23661   unsigned int jresult ;
23662   Dali::Image *arg1 = (Dali::Image *) 0 ;
23663   unsigned int result;
23664
23665   arg1 = (Dali::Image *)jarg1;
23666   {
23667     try {
23668       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
23669     } catch (std::out_of_range& e) {
23670       {
23671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23672       };
23673     } catch (std::exception& e) {
23674       {
23675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23676       };
23677     } catch (Dali::DaliException e) {
23678       {
23679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23680       };
23681     } catch (...) {
23682       {
23683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23684       };
23685     }
23686   }
23687
23688   jresult = result;
23689   return jresult;
23690 }
23691
23692
23693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
23694   void * jresult ;
23695   Dali::Image *arg1 = (Dali::Image *) 0 ;
23696   Dali::Image::ImageSignalType *result = 0 ;
23697
23698   arg1 = (Dali::Image *)jarg1;
23699   {
23700     try {
23701       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
23702     } catch (std::out_of_range& e) {
23703       {
23704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23705       };
23706     } catch (std::exception& e) {
23707       {
23708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23709       };
23710     } catch (Dali::DaliException e) {
23711       {
23712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23713       };
23714     } catch (...) {
23715       {
23716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23717       };
23718     }
23719   }
23720
23721   jresult = (void *)result;
23722   return jresult;
23723 }
23724
23725
23726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
23727   int jresult ;
23728   Dali::Pixel::Format result;
23729
23730   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
23731   jresult = (int)result;
23732   return jresult;
23733 }
23734
23735
23736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
23737   int jresult ;
23738   Dali::Pixel::Format result;
23739
23740   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
23741   jresult = (int)result;
23742   return jresult;
23743 }
23744
23745
23746 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
23747   unsigned int jresult ;
23748   Dali::Pixel::Format arg1 ;
23749   bool result;
23750
23751   arg1 = (Dali::Pixel::Format)jarg1;
23752   {
23753     try {
23754       result = (bool)Dali::Pixel::HasAlpha(arg1);
23755     } catch (std::out_of_range& e) {
23756       {
23757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23758       };
23759     } catch (std::exception& e) {
23760       {
23761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23762       };
23763     } catch (Dali::DaliException e) {
23764       {
23765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23766       };
23767     } catch (...) {
23768       {
23769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23770       };
23771     }
23772   }
23773
23774   jresult = result;
23775   return jresult;
23776 }
23777
23778
23779 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
23780   unsigned int jresult ;
23781   Dali::Pixel::Format arg1 ;
23782   unsigned int result;
23783
23784   arg1 = (Dali::Pixel::Format)jarg1;
23785   {
23786     try {
23787       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
23788     } catch (std::out_of_range& e) {
23789       {
23790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23791       };
23792     } catch (std::exception& e) {
23793       {
23794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23795       };
23796     } catch (Dali::DaliException e) {
23797       {
23798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23799       };
23800     } catch (...) {
23801       {
23802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23803       };
23804     }
23805   }
23806
23807   jresult = result;
23808   return jresult;
23809 }
23810
23811
23812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
23813   Dali::Pixel::Format arg1 ;
23814   int *arg2 = 0 ;
23815   int *arg3 = 0 ;
23816
23817   arg1 = (Dali::Pixel::Format)jarg1;
23818   arg2 = (int *)jarg2;
23819   if (!arg2) {
23820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23821     return ;
23822   }
23823   arg3 = (int *)jarg3;
23824   if (!arg3) {
23825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23826     return ;
23827   }
23828   {
23829     try {
23830       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
23831     } catch (std::out_of_range& e) {
23832       {
23833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23834       };
23835     } catch (std::exception& e) {
23836       {
23837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23838       };
23839     } catch (Dali::DaliException e) {
23840       {
23841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23842       };
23843     } catch (...) {
23844       {
23845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23846       };
23847     }
23848   }
23849
23850 }
23851
23852
23853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
23854   void * jresult ;
23855   unsigned char *arg1 = (unsigned char *) 0 ;
23856   unsigned int arg2 ;
23857   unsigned int arg3 ;
23858   unsigned int arg4 ;
23859   Dali::Pixel::Format arg5 ;
23860   Dali::PixelData::ReleaseFunction arg6 ;
23861   Dali::PixelData result;
23862
23863   arg1 = jarg1;
23864   arg2 = (unsigned int)jarg2;
23865   arg3 = (unsigned int)jarg3;
23866   arg4 = (unsigned int)jarg4;
23867   arg5 = (Dali::Pixel::Format)jarg5;
23868   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
23869   {
23870     try {
23871       result = Dali::PixelData::New(arg1,arg2,arg3,arg4,arg5,arg6);
23872     } catch (std::out_of_range& e) {
23873       {
23874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23875       };
23876     } catch (std::exception& e) {
23877       {
23878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23879       };
23880     } catch (Dali::DaliException e) {
23881       {
23882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23883       };
23884     } catch (...) {
23885       {
23886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23887       };
23888     }
23889   }
23890
23891   jresult = new Dali::PixelData((const Dali::PixelData &)result);
23892
23893
23894   return jresult;
23895 }
23896
23897
23898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
23899   void * jresult ;
23900   Dali::PixelData *result = 0 ;
23901
23902   {
23903     try {
23904       result = (Dali::PixelData *)new Dali::PixelData();
23905     } catch (std::out_of_range& e) {
23906       {
23907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23908       };
23909     } catch (std::exception& e) {
23910       {
23911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23912       };
23913     } catch (Dali::DaliException e) {
23914       {
23915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23916       };
23917     } catch (...) {
23918       {
23919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23920       };
23921     }
23922   }
23923
23924   jresult = (void *)result;
23925   return jresult;
23926 }
23927
23928
23929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
23930   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23931
23932   arg1 = (Dali::PixelData *)jarg1;
23933   {
23934     try {
23935       delete arg1;
23936     } catch (std::out_of_range& e) {
23937       {
23938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23939       };
23940     } catch (std::exception& e) {
23941       {
23942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23943       };
23944     } catch (Dali::DaliException e) {
23945       {
23946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23947       };
23948     } catch (...) {
23949       {
23950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23951       };
23952     }
23953   }
23954
23955 }
23956
23957
23958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
23959   void * jresult ;
23960   Dali::PixelData *arg1 = 0 ;
23961   Dali::PixelData *result = 0 ;
23962
23963   arg1 = (Dali::PixelData *)jarg1;
23964   if (!arg1) {
23965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
23966     return 0;
23967   }
23968   {
23969     try {
23970       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
23971     } catch (std::out_of_range& e) {
23972       {
23973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23974       };
23975     } catch (std::exception& e) {
23976       {
23977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23978       };
23979     } catch (Dali::DaliException e) {
23980       {
23981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23982       };
23983     } catch (...) {
23984       {
23985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23986       };
23987     }
23988   }
23989
23990   jresult = (void *)result;
23991   return jresult;
23992 }
23993
23994
23995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
23996   void * jresult ;
23997   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23998   Dali::PixelData *arg2 = 0 ;
23999   Dali::PixelData *result = 0 ;
24000
24001   arg1 = (Dali::PixelData *)jarg1;
24002   arg2 = (Dali::PixelData *)jarg2;
24003   if (!arg2) {
24004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24005     return 0;
24006   }
24007   {
24008     try {
24009       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
24010     } catch (std::out_of_range& e) {
24011       {
24012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24013       };
24014     } catch (std::exception& e) {
24015       {
24016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24017       };
24018     } catch (Dali::DaliException e) {
24019       {
24020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24021       };
24022     } catch (...) {
24023       {
24024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24025       };
24026     }
24027   }
24028
24029   jresult = (void *)result;
24030   return jresult;
24031 }
24032
24033
24034 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
24035   unsigned int jresult ;
24036   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24037   unsigned int result;
24038
24039   arg1 = (Dali::PixelData *)jarg1;
24040   {
24041     try {
24042       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
24043     } catch (std::out_of_range& e) {
24044       {
24045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24046       };
24047     } catch (std::exception& e) {
24048       {
24049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24050       };
24051     } catch (Dali::DaliException e) {
24052       {
24053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24054       };
24055     } catch (...) {
24056       {
24057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24058       };
24059     }
24060   }
24061
24062   jresult = result;
24063   return jresult;
24064 }
24065
24066
24067 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
24068   unsigned int jresult ;
24069   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24070   unsigned int result;
24071
24072   arg1 = (Dali::PixelData *)jarg1;
24073   {
24074     try {
24075       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
24076     } catch (std::out_of_range& e) {
24077       {
24078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24079       };
24080     } catch (std::exception& e) {
24081       {
24082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24083       };
24084     } catch (Dali::DaliException e) {
24085       {
24086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24087       };
24088     } catch (...) {
24089       {
24090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24091       };
24092     }
24093   }
24094
24095   jresult = result;
24096   return jresult;
24097 }
24098
24099
24100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
24101   int jresult ;
24102   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24103   Dali::Pixel::Format result;
24104
24105   arg1 = (Dali::PixelData *)jarg1;
24106   {
24107     try {
24108       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
24109     } catch (std::out_of_range& e) {
24110       {
24111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24112       };
24113     } catch (std::exception& e) {
24114       {
24115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24116       };
24117     } catch (Dali::DaliException e) {
24118       {
24119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24120       };
24121     } catch (...) {
24122       {
24123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24124       };
24125     }
24126   }
24127
24128   jresult = (int)result;
24129   return jresult;
24130 }
24131
24132
24133 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
24134   unsigned int jresult ;
24135   unsigned int result;
24136
24137   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
24138   jresult = result;
24139   return jresult;
24140 }
24141
24142
24143 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
24144   unsigned int jresult ;
24145   unsigned int result;
24146
24147   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
24148   jresult = result;
24149   return jresult;
24150 }
24151
24152
24153 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
24154   unsigned int jresult ;
24155   unsigned int result;
24156
24157   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
24158   jresult = result;
24159   return jresult;
24160 }
24161
24162
24163 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
24164   unsigned int jresult ;
24165   unsigned int result;
24166
24167   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
24168   jresult = result;
24169   return jresult;
24170 }
24171
24172
24173 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
24174   unsigned int jresult ;
24175   unsigned int result;
24176
24177   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
24178   jresult = result;
24179   return jresult;
24180 }
24181
24182
24183 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
24184   unsigned int jresult ;
24185   unsigned int result;
24186
24187   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
24188   jresult = result;
24189   return jresult;
24190 }
24191
24192
24193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
24194   void * jresult ;
24195   Dali::TextureType::Type arg1 ;
24196   Dali::Pixel::Format arg2 ;
24197   unsigned int arg3 ;
24198   unsigned int arg4 ;
24199   Dali::Texture result;
24200
24201   arg1 = (Dali::TextureType::Type)jarg1;
24202   arg2 = (Dali::Pixel::Format)jarg2;
24203   arg3 = (unsigned int)jarg3;
24204   arg4 = (unsigned int)jarg4;
24205   {
24206     try {
24207       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
24208     } catch (std::out_of_range& e) {
24209       {
24210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24211       };
24212     } catch (std::exception& e) {
24213       {
24214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24215       };
24216     } catch (Dali::DaliException e) {
24217       {
24218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24219       };
24220     } catch (...) {
24221       {
24222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24223       };
24224     }
24225   }
24226
24227   jresult = new Dali::Texture((const Dali::Texture &)result);
24228   return jresult;
24229 }
24230
24231
24232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
24233   void * jresult ;
24234   NativeImageInterface *arg1 = 0 ;
24235   Dali::Texture result;
24236
24237   arg1 = (NativeImageInterface *)jarg1;
24238   if (!arg1) {
24239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
24240     return 0;
24241   }
24242   {
24243     try {
24244       result = Dali::Texture::New(*arg1);
24245     } catch (std::out_of_range& e) {
24246       {
24247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24248       };
24249     } catch (std::exception& e) {
24250       {
24251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24252       };
24253     } catch (Dali::DaliException e) {
24254       {
24255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24256       };
24257     } catch (...) {
24258       {
24259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24260       };
24261     }
24262   }
24263
24264   jresult = new Dali::Texture((const Dali::Texture &)result);
24265   return jresult;
24266 }
24267
24268
24269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
24270   void * jresult ;
24271   Dali::Texture *result = 0 ;
24272
24273   {
24274     try {
24275       result = (Dali::Texture *)new Dali::Texture();
24276     } catch (std::out_of_range& e) {
24277       {
24278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24279       };
24280     } catch (std::exception& e) {
24281       {
24282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24283       };
24284     } catch (Dali::DaliException e) {
24285       {
24286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24287       };
24288     } catch (...) {
24289       {
24290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24291       };
24292     }
24293   }
24294
24295   jresult = (void *)result;
24296   return jresult;
24297 }
24298
24299
24300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
24301   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24302
24303   arg1 = (Dali::Texture *)jarg1;
24304   {
24305     try {
24306       delete arg1;
24307     } catch (std::out_of_range& e) {
24308       {
24309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24310       };
24311     } catch (std::exception& e) {
24312       {
24313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24314       };
24315     } catch (Dali::DaliException e) {
24316       {
24317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24318       };
24319     } catch (...) {
24320       {
24321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24322       };
24323     }
24324   }
24325
24326 }
24327
24328
24329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
24330   void * jresult ;
24331   Dali::Texture *arg1 = 0 ;
24332   Dali::Texture *result = 0 ;
24333
24334   arg1 = (Dali::Texture *)jarg1;
24335   if (!arg1) {
24336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24337     return 0;
24338   }
24339   {
24340     try {
24341       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
24342     } catch (std::out_of_range& e) {
24343       {
24344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24345       };
24346     } catch (std::exception& e) {
24347       {
24348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24349       };
24350     } catch (Dali::DaliException e) {
24351       {
24352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24353       };
24354     } catch (...) {
24355       {
24356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24357       };
24358     }
24359   }
24360
24361   jresult = (void *)result;
24362   return jresult;
24363 }
24364
24365
24366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
24367   void * jresult ;
24368   Dali::BaseHandle arg1 ;
24369   Dali::BaseHandle *argp1 ;
24370   Dali::Texture result;
24371
24372   argp1 = (Dali::BaseHandle *)jarg1;
24373   if (!argp1) {
24374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24375     return 0;
24376   }
24377   arg1 = *argp1;
24378   {
24379     try {
24380       result = Dali::Texture::DownCast(arg1);
24381     } catch (std::out_of_range& e) {
24382       {
24383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24384       };
24385     } catch (std::exception& e) {
24386       {
24387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24388       };
24389     } catch (Dali::DaliException e) {
24390       {
24391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24392       };
24393     } catch (...) {
24394       {
24395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24396       };
24397     }
24398   }
24399
24400   jresult = new Dali::Texture((const Dali::Texture &)result);
24401   return jresult;
24402 }
24403
24404
24405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
24406   void * jresult ;
24407   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24408   Dali::Texture *arg2 = 0 ;
24409   Dali::Texture *result = 0 ;
24410
24411   arg1 = (Dali::Texture *)jarg1;
24412   arg2 = (Dali::Texture *)jarg2;
24413   if (!arg2) {
24414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24415     return 0;
24416   }
24417   {
24418     try {
24419       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
24420     } catch (std::out_of_range& e) {
24421       {
24422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24423       };
24424     } catch (std::exception& e) {
24425       {
24426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24427       };
24428     } catch (Dali::DaliException e) {
24429       {
24430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24431       };
24432     } catch (...) {
24433       {
24434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24435       };
24436     }
24437   }
24438
24439   jresult = (void *)result;
24440   return jresult;
24441 }
24442
24443
24444 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
24445   unsigned int jresult ;
24446   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24447   Dali::PixelData arg2 ;
24448   Dali::PixelData *argp2 ;
24449   bool result;
24450
24451   arg1 = (Dali::Texture *)jarg1;
24452   argp2 = (Dali::PixelData *)jarg2;
24453   if (!argp2) {
24454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24455     return 0;
24456   }
24457   arg2 = *argp2;
24458   {
24459     try {
24460       result = (bool)(arg1)->Upload(arg2);
24461     } catch (std::out_of_range& e) {
24462       {
24463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24464       };
24465     } catch (std::exception& e) {
24466       {
24467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24468       };
24469     } catch (Dali::DaliException e) {
24470       {
24471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24472       };
24473     } catch (...) {
24474       {
24475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24476       };
24477     }
24478   }
24479
24480   jresult = result;
24481   return jresult;
24482 }
24483
24484
24485 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) {
24486   unsigned int jresult ;
24487   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24488   Dali::PixelData arg2 ;
24489   unsigned int arg3 ;
24490   unsigned int arg4 ;
24491   unsigned int arg5 ;
24492   unsigned int arg6 ;
24493   unsigned int arg7 ;
24494   unsigned int arg8 ;
24495   Dali::PixelData *argp2 ;
24496   bool result;
24497
24498   arg1 = (Dali::Texture *)jarg1;
24499   argp2 = (Dali::PixelData *)jarg2;
24500   if (!argp2) {
24501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24502     return 0;
24503   }
24504   arg2 = *argp2;
24505   arg3 = (unsigned int)jarg3;
24506   arg4 = (unsigned int)jarg4;
24507   arg5 = (unsigned int)jarg5;
24508   arg6 = (unsigned int)jarg6;
24509   arg7 = (unsigned int)jarg7;
24510   arg8 = (unsigned int)jarg8;
24511   {
24512     try {
24513       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24514     } catch (std::out_of_range& e) {
24515       {
24516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24517       };
24518     } catch (std::exception& e) {
24519       {
24520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24521       };
24522     } catch (Dali::DaliException e) {
24523       {
24524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24525       };
24526     } catch (...) {
24527       {
24528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24529       };
24530     }
24531   }
24532
24533   jresult = result;
24534   return jresult;
24535 }
24536
24537
24538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
24539   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24540
24541   arg1 = (Dali::Texture *)jarg1;
24542   {
24543     try {
24544       (arg1)->GenerateMipmaps();
24545     } catch (std::out_of_range& e) {
24546       {
24547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24548       };
24549     } catch (std::exception& e) {
24550       {
24551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24552       };
24553     } catch (Dali::DaliException e) {
24554       {
24555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24556       };
24557     } catch (...) {
24558       {
24559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24560       };
24561     }
24562   }
24563
24564 }
24565
24566
24567 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
24568   unsigned int jresult ;
24569   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24570   unsigned int result;
24571
24572   arg1 = (Dali::Texture *)jarg1;
24573   {
24574     try {
24575       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
24576     } catch (std::out_of_range& e) {
24577       {
24578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24579       };
24580     } catch (std::exception& e) {
24581       {
24582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24583       };
24584     } catch (Dali::DaliException e) {
24585       {
24586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24587       };
24588     } catch (...) {
24589       {
24590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24591       };
24592     }
24593   }
24594
24595   jresult = result;
24596   return jresult;
24597 }
24598
24599
24600 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
24601   unsigned int jresult ;
24602   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24603   unsigned int result;
24604
24605   arg1 = (Dali::Texture *)jarg1;
24606   {
24607     try {
24608       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
24609     } catch (std::out_of_range& e) {
24610       {
24611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24612       };
24613     } catch (std::exception& e) {
24614       {
24615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24616       };
24617     } catch (Dali::DaliException e) {
24618       {
24619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24620       };
24621     } catch (...) {
24622       {
24623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24624       };
24625     }
24626   }
24627
24628   jresult = result;
24629   return jresult;
24630 }
24631
24632
24633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_2(void * jarg1) {
24634   void * jresult ;
24635   Dali::Internal::Texture *arg1 = (Dali::Internal::Texture *) 0 ;
24636   Dali::Texture *result = 0 ;
24637
24638   arg1 = (Dali::Internal::Texture *)jarg1;
24639   {
24640     try {
24641       result = (Dali::Texture *)new Dali::Texture(arg1);
24642     } catch (std::out_of_range& e) {
24643       {
24644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24645       };
24646     } catch (std::exception& e) {
24647       {
24648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24649       };
24650     } catch (Dali::DaliException e) {
24651       {
24652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24653       };
24654     } catch (...) {
24655       {
24656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24657       };
24658     }
24659   }
24660
24661   jresult = (void *)result;
24662   return jresult;
24663 }
24664
24665
24666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
24667   void * jresult ;
24668   Dali::Sampler result;
24669
24670   {
24671     try {
24672       result = Dali::Sampler::New();
24673     } catch (std::out_of_range& e) {
24674       {
24675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24676       };
24677     } catch (std::exception& e) {
24678       {
24679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24680       };
24681     } catch (Dali::DaliException e) {
24682       {
24683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24684       };
24685     } catch (...) {
24686       {
24687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24688       };
24689     }
24690   }
24691
24692   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24693   return jresult;
24694 }
24695
24696
24697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
24698   void * jresult ;
24699   Dali::Sampler *result = 0 ;
24700
24701   {
24702     try {
24703       result = (Dali::Sampler *)new Dali::Sampler();
24704     } catch (std::out_of_range& e) {
24705       {
24706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24707       };
24708     } catch (std::exception& e) {
24709       {
24710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24711       };
24712     } catch (Dali::DaliException e) {
24713       {
24714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24715       };
24716     } catch (...) {
24717       {
24718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24719       };
24720     }
24721   }
24722
24723   jresult = (void *)result;
24724   return jresult;
24725 }
24726
24727
24728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
24729   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24730
24731   arg1 = (Dali::Sampler *)jarg1;
24732   {
24733     try {
24734       delete arg1;
24735     } catch (std::out_of_range& e) {
24736       {
24737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24738       };
24739     } catch (std::exception& e) {
24740       {
24741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24742       };
24743     } catch (Dali::DaliException e) {
24744       {
24745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24746       };
24747     } catch (...) {
24748       {
24749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24750       };
24751     }
24752   }
24753
24754 }
24755
24756
24757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
24758   void * jresult ;
24759   Dali::Sampler *arg1 = 0 ;
24760   Dali::Sampler *result = 0 ;
24761
24762   arg1 = (Dali::Sampler *)jarg1;
24763   if (!arg1) {
24764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24765     return 0;
24766   }
24767   {
24768     try {
24769       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
24770     } catch (std::out_of_range& e) {
24771       {
24772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24773       };
24774     } catch (std::exception& e) {
24775       {
24776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24777       };
24778     } catch (Dali::DaliException e) {
24779       {
24780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24781       };
24782     } catch (...) {
24783       {
24784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24785       };
24786     }
24787   }
24788
24789   jresult = (void *)result;
24790   return jresult;
24791 }
24792
24793
24794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
24795   void * jresult ;
24796   Dali::BaseHandle arg1 ;
24797   Dali::BaseHandle *argp1 ;
24798   Dali::Sampler result;
24799
24800   argp1 = (Dali::BaseHandle *)jarg1;
24801   if (!argp1) {
24802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24803     return 0;
24804   }
24805   arg1 = *argp1;
24806   {
24807     try {
24808       result = Dali::Sampler::DownCast(arg1);
24809     } catch (std::out_of_range& e) {
24810       {
24811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24812       };
24813     } catch (std::exception& e) {
24814       {
24815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24816       };
24817     } catch (Dali::DaliException e) {
24818       {
24819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24820       };
24821     } catch (...) {
24822       {
24823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24824       };
24825     }
24826   }
24827
24828   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24829   return jresult;
24830 }
24831
24832
24833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
24834   void * jresult ;
24835   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24836   Dali::Sampler *arg2 = 0 ;
24837   Dali::Sampler *result = 0 ;
24838
24839   arg1 = (Dali::Sampler *)jarg1;
24840   arg2 = (Dali::Sampler *)jarg2;
24841   if (!arg2) {
24842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24843     return 0;
24844   }
24845   {
24846     try {
24847       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
24848     } catch (std::out_of_range& e) {
24849       {
24850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24851       };
24852     } catch (std::exception& e) {
24853       {
24854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24855       };
24856     } catch (Dali::DaliException e) {
24857       {
24858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24859       };
24860     } catch (...) {
24861       {
24862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24863       };
24864     }
24865   }
24866
24867   jresult = (void *)result;
24868   return jresult;
24869 }
24870
24871
24872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
24873   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24874   Dali::FilterMode::Type arg2 ;
24875   Dali::FilterMode::Type arg3 ;
24876
24877   arg1 = (Dali::Sampler *)jarg1;
24878   arg2 = (Dali::FilterMode::Type)jarg2;
24879   arg3 = (Dali::FilterMode::Type)jarg3;
24880   {
24881     try {
24882       (arg1)->SetFilterMode(arg2,arg3);
24883     } catch (std::out_of_range& e) {
24884       {
24885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24886       };
24887     } catch (std::exception& e) {
24888       {
24889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24890       };
24891     } catch (Dali::DaliException e) {
24892       {
24893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24894       };
24895     } catch (...) {
24896       {
24897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24898       };
24899     }
24900   }
24901
24902 }
24903
24904
24905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
24906   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24907   Dali::WrapMode::Type arg2 ;
24908   Dali::WrapMode::Type arg3 ;
24909
24910   arg1 = (Dali::Sampler *)jarg1;
24911   arg2 = (Dali::WrapMode::Type)jarg2;
24912   arg3 = (Dali::WrapMode::Type)jarg3;
24913   {
24914     try {
24915       (arg1)->SetWrapMode(arg2,arg3);
24916     } catch (std::out_of_range& e) {
24917       {
24918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24919       };
24920     } catch (std::exception& e) {
24921       {
24922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24923       };
24924     } catch (Dali::DaliException e) {
24925       {
24926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24927       };
24928     } catch (...) {
24929       {
24930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24931       };
24932     }
24933   }
24934
24935 }
24936
24937
24938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
24939   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24940   Dali::WrapMode::Type arg2 ;
24941   Dali::WrapMode::Type arg3 ;
24942   Dali::WrapMode::Type arg4 ;
24943
24944   arg1 = (Dali::Sampler *)jarg1;
24945   arg2 = (Dali::WrapMode::Type)jarg2;
24946   arg3 = (Dali::WrapMode::Type)jarg3;
24947   arg4 = (Dali::WrapMode::Type)jarg4;
24948   {
24949     try {
24950       (arg1)->SetWrapMode(arg2,arg3,arg4);
24951     } catch (std::out_of_range& e) {
24952       {
24953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24954       };
24955     } catch (std::exception& e) {
24956       {
24957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24958       };
24959     } catch (Dali::DaliException e) {
24960       {
24961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24962       };
24963     } catch (...) {
24964       {
24965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24966       };
24967     }
24968   }
24969
24970 }
24971
24972
24973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
24974   void * jresult ;
24975   Dali::TextureSet result;
24976
24977   {
24978     try {
24979       result = Dali::TextureSet::New();
24980     } catch (std::out_of_range& e) {
24981       {
24982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24983       };
24984     } catch (std::exception& e) {
24985       {
24986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24987       };
24988     } catch (Dali::DaliException e) {
24989       {
24990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24991       };
24992     } catch (...) {
24993       {
24994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24995       };
24996     }
24997   }
24998
24999   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25000   return jresult;
25001 }
25002
25003
25004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
25005   void * jresult ;
25006   Dali::TextureSet *result = 0 ;
25007
25008   {
25009     try {
25010       result = (Dali::TextureSet *)new Dali::TextureSet();
25011     } catch (std::out_of_range& e) {
25012       {
25013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25014       };
25015     } catch (std::exception& e) {
25016       {
25017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25018       };
25019     } catch (Dali::DaliException e) {
25020       {
25021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25022       };
25023     } catch (...) {
25024       {
25025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25026       };
25027     }
25028   }
25029
25030   jresult = (void *)result;
25031   return jresult;
25032 }
25033
25034
25035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
25036   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25037
25038   arg1 = (Dali::TextureSet *)jarg1;
25039   {
25040     try {
25041       delete arg1;
25042     } catch (std::out_of_range& e) {
25043       {
25044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25045       };
25046     } catch (std::exception& e) {
25047       {
25048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25049       };
25050     } catch (Dali::DaliException e) {
25051       {
25052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25053       };
25054     } catch (...) {
25055       {
25056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25057       };
25058     }
25059   }
25060
25061 }
25062
25063
25064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
25065   void * jresult ;
25066   Dali::TextureSet *arg1 = 0 ;
25067   Dali::TextureSet *result = 0 ;
25068
25069   arg1 = (Dali::TextureSet *)jarg1;
25070   if (!arg1) {
25071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25072     return 0;
25073   }
25074   {
25075     try {
25076       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
25077     } catch (std::out_of_range& e) {
25078       {
25079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25080       };
25081     } catch (std::exception& e) {
25082       {
25083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25084       };
25085     } catch (Dali::DaliException e) {
25086       {
25087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25088       };
25089     } catch (...) {
25090       {
25091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25092       };
25093     }
25094   }
25095
25096   jresult = (void *)result;
25097   return jresult;
25098 }
25099
25100
25101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
25102   void * jresult ;
25103   Dali::BaseHandle arg1 ;
25104   Dali::BaseHandle *argp1 ;
25105   Dali::TextureSet result;
25106
25107   argp1 = (Dali::BaseHandle *)jarg1;
25108   if (!argp1) {
25109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25110     return 0;
25111   }
25112   arg1 = *argp1;
25113   {
25114     try {
25115       result = Dali::TextureSet::DownCast(arg1);
25116     } catch (std::out_of_range& e) {
25117       {
25118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25119       };
25120     } catch (std::exception& e) {
25121       {
25122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25123       };
25124     } catch (Dali::DaliException e) {
25125       {
25126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25127       };
25128     } catch (...) {
25129       {
25130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25131       };
25132     }
25133   }
25134
25135   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25136   return jresult;
25137 }
25138
25139
25140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
25141   void * jresult ;
25142   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25143   Dali::TextureSet *arg2 = 0 ;
25144   Dali::TextureSet *result = 0 ;
25145
25146   arg1 = (Dali::TextureSet *)jarg1;
25147   arg2 = (Dali::TextureSet *)jarg2;
25148   if (!arg2) {
25149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25150     return 0;
25151   }
25152   {
25153     try {
25154       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
25155     } catch (std::out_of_range& e) {
25156       {
25157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25158       };
25159     } catch (std::exception& e) {
25160       {
25161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25162       };
25163     } catch (Dali::DaliException e) {
25164       {
25165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25166       };
25167     } catch (...) {
25168       {
25169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25170       };
25171     }
25172   }
25173
25174   jresult = (void *)result;
25175   return jresult;
25176 }
25177
25178
25179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
25180   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25181   size_t arg2 ;
25182   Dali::Texture arg3 ;
25183   Dali::Texture *argp3 ;
25184
25185   arg1 = (Dali::TextureSet *)jarg1;
25186   arg2 = (size_t)jarg2;
25187   argp3 = (Dali::Texture *)jarg3;
25188   if (!argp3) {
25189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
25190     return ;
25191   }
25192   arg3 = *argp3;
25193   {
25194     try {
25195       (arg1)->SetTexture(arg2,arg3);
25196     } catch (std::out_of_range& e) {
25197       {
25198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25199       };
25200     } catch (std::exception& e) {
25201       {
25202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25203       };
25204     } catch (Dali::DaliException e) {
25205       {
25206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25207       };
25208     } catch (...) {
25209       {
25210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25211       };
25212     }
25213   }
25214
25215 }
25216
25217
25218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
25219   void * jresult ;
25220   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25221   size_t arg2 ;
25222   Dali::Texture result;
25223
25224   arg1 = (Dali::TextureSet *)jarg1;
25225   arg2 = (size_t)jarg2;
25226   {
25227     try {
25228       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
25229     } catch (std::out_of_range& e) {
25230       {
25231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25232       };
25233     } catch (std::exception& e) {
25234       {
25235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25236       };
25237     } catch (Dali::DaliException e) {
25238       {
25239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25240       };
25241     } catch (...) {
25242       {
25243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25244       };
25245     }
25246   }
25247
25248   jresult = new Dali::Texture((const Dali::Texture &)result);
25249   return jresult;
25250 }
25251
25252
25253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
25254   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25255   size_t arg2 ;
25256   Dali::Sampler arg3 ;
25257   Dali::Sampler *argp3 ;
25258
25259   arg1 = (Dali::TextureSet *)jarg1;
25260   arg2 = (size_t)jarg2;
25261   argp3 = (Dali::Sampler *)jarg3;
25262   if (!argp3) {
25263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
25264     return ;
25265   }
25266   arg3 = *argp3;
25267   {
25268     try {
25269       (arg1)->SetSampler(arg2,arg3);
25270     } catch (std::out_of_range& e) {
25271       {
25272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25273       };
25274     } catch (std::exception& e) {
25275       {
25276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25277       };
25278     } catch (Dali::DaliException e) {
25279       {
25280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25281       };
25282     } catch (...) {
25283       {
25284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25285       };
25286     }
25287   }
25288
25289 }
25290
25291
25292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
25293   void * jresult ;
25294   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25295   size_t arg2 ;
25296   Dali::Sampler result;
25297
25298   arg1 = (Dali::TextureSet *)jarg1;
25299   arg2 = (size_t)jarg2;
25300   {
25301     try {
25302       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
25303     } catch (std::out_of_range& e) {
25304       {
25305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25306       };
25307     } catch (std::exception& e) {
25308       {
25309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25310       };
25311     } catch (Dali::DaliException e) {
25312       {
25313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25314       };
25315     } catch (...) {
25316       {
25317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25318       };
25319     }
25320   }
25321
25322   jresult = new Dali::Sampler((const Dali::Sampler &)result);
25323   return jresult;
25324 }
25325
25326
25327 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
25328   unsigned long jresult ;
25329   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25330   size_t result;
25331
25332   arg1 = (Dali::TextureSet *)jarg1;
25333   {
25334     try {
25335       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
25336     } catch (std::out_of_range& e) {
25337       {
25338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25339       };
25340     } catch (std::exception& e) {
25341       {
25342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25343       };
25344     } catch (Dali::DaliException e) {
25345       {
25346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25347       };
25348     } catch (...) {
25349       {
25350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25351       };
25352     }
25353   }
25354
25355   jresult = (unsigned long)result;
25356   return jresult;
25357 }
25358
25359
25360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
25361   void * jresult ;
25362   Dali::Property::Map *arg1 = 0 ;
25363   Dali::PropertyBuffer result;
25364
25365   arg1 = (Dali::Property::Map *)jarg1;
25366   if (!arg1) {
25367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
25368     return 0;
25369   }
25370   {
25371     try {
25372       result = Dali::PropertyBuffer::New(*arg1);
25373     } catch (std::out_of_range& e) {
25374       {
25375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25376       };
25377     } catch (std::exception& e) {
25378       {
25379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25380       };
25381     } catch (Dali::DaliException e) {
25382       {
25383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25384       };
25385     } catch (...) {
25386       {
25387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25388       };
25389     }
25390   }
25391
25392   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25393   return jresult;
25394 }
25395
25396
25397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
25398   void * jresult ;
25399   Dali::PropertyBuffer *result = 0 ;
25400
25401   {
25402     try {
25403       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
25404     } catch (std::out_of_range& e) {
25405       {
25406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25407       };
25408     } catch (std::exception& e) {
25409       {
25410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25411       };
25412     } catch (Dali::DaliException e) {
25413       {
25414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25415       };
25416     } catch (...) {
25417       {
25418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25419       };
25420     }
25421   }
25422
25423   jresult = (void *)result;
25424   return jresult;
25425 }
25426
25427
25428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
25429   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25430
25431   arg1 = (Dali::PropertyBuffer *)jarg1;
25432   {
25433     try {
25434       delete arg1;
25435     } catch (std::out_of_range& e) {
25436       {
25437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25438       };
25439     } catch (std::exception& e) {
25440       {
25441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25442       };
25443     } catch (Dali::DaliException e) {
25444       {
25445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25446       };
25447     } catch (...) {
25448       {
25449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25450       };
25451     }
25452   }
25453
25454 }
25455
25456
25457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
25458   void * jresult ;
25459   Dali::PropertyBuffer *arg1 = 0 ;
25460   Dali::PropertyBuffer *result = 0 ;
25461
25462   arg1 = (Dali::PropertyBuffer *)jarg1;
25463   if (!arg1) {
25464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25465     return 0;
25466   }
25467   {
25468     try {
25469       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
25470     } catch (std::out_of_range& e) {
25471       {
25472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25473       };
25474     } catch (std::exception& e) {
25475       {
25476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25477       };
25478     } catch (Dali::DaliException e) {
25479       {
25480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25481       };
25482     } catch (...) {
25483       {
25484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25485       };
25486     }
25487   }
25488
25489   jresult = (void *)result;
25490   return jresult;
25491 }
25492
25493
25494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
25495   void * jresult ;
25496   Dali::BaseHandle arg1 ;
25497   Dali::BaseHandle *argp1 ;
25498   Dali::PropertyBuffer result;
25499
25500   argp1 = (Dali::BaseHandle *)jarg1;
25501   if (!argp1) {
25502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25503     return 0;
25504   }
25505   arg1 = *argp1;
25506   {
25507     try {
25508       result = Dali::PropertyBuffer::DownCast(arg1);
25509     } catch (std::out_of_range& e) {
25510       {
25511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25512       };
25513     } catch (std::exception& e) {
25514       {
25515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25516       };
25517     } catch (Dali::DaliException e) {
25518       {
25519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25520       };
25521     } catch (...) {
25522       {
25523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25524       };
25525     }
25526   }
25527
25528   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25529   return jresult;
25530 }
25531
25532
25533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
25534   void * jresult ;
25535   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25536   Dali::PropertyBuffer *arg2 = 0 ;
25537   Dali::PropertyBuffer *result = 0 ;
25538
25539   arg1 = (Dali::PropertyBuffer *)jarg1;
25540   arg2 = (Dali::PropertyBuffer *)jarg2;
25541   if (!arg2) {
25542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25543     return 0;
25544   }
25545   {
25546     try {
25547       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
25548     } catch (std::out_of_range& e) {
25549       {
25550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25551       };
25552     } catch (std::exception& e) {
25553       {
25554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25555       };
25556     } catch (Dali::DaliException e) {
25557       {
25558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25559       };
25560     } catch (...) {
25561       {
25562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25563       };
25564     }
25565   }
25566
25567   jresult = (void *)result;
25568   return jresult;
25569 }
25570
25571
25572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
25573   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25574   void *arg2 = (void *) 0 ;
25575   std::size_t arg3 ;
25576
25577   arg1 = (Dali::PropertyBuffer *)jarg1;
25578   arg2 = jarg2;
25579   arg3 = (std::size_t)jarg3;
25580   {
25581     try {
25582       (arg1)->SetData((void const *)arg2,arg3);
25583     } catch (std::out_of_range& e) {
25584       {
25585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25586       };
25587     } catch (std::exception& e) {
25588       {
25589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25590       };
25591     } catch (Dali::DaliException e) {
25592       {
25593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25594       };
25595     } catch (...) {
25596       {
25597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25598       };
25599     }
25600   }
25601
25602 }
25603
25604
25605 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
25606   unsigned long jresult ;
25607   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25608   std::size_t result;
25609
25610   arg1 = (Dali::PropertyBuffer *)jarg1;
25611   {
25612     try {
25613       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
25614     } catch (std::out_of_range& e) {
25615       {
25616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25617       };
25618     } catch (std::exception& e) {
25619       {
25620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25621       };
25622     } catch (Dali::DaliException e) {
25623       {
25624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25625       };
25626     } catch (...) {
25627       {
25628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25629       };
25630     }
25631   }
25632
25633   jresult = (unsigned long)result;
25634   return jresult;
25635 }
25636
25637
25638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
25639   void * jresult ;
25640   Dali::Geometry result;
25641
25642   {
25643     try {
25644       result = Dali::Geometry::New();
25645     } catch (std::out_of_range& e) {
25646       {
25647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25648       };
25649     } catch (std::exception& e) {
25650       {
25651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25652       };
25653     } catch (Dali::DaliException e) {
25654       {
25655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25656       };
25657     } catch (...) {
25658       {
25659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25660       };
25661     }
25662   }
25663
25664   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25665   return jresult;
25666 }
25667
25668
25669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
25670   void * jresult ;
25671   Dali::Geometry *result = 0 ;
25672
25673   {
25674     try {
25675       result = (Dali::Geometry *)new Dali::Geometry();
25676     } catch (std::out_of_range& e) {
25677       {
25678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25679       };
25680     } catch (std::exception& e) {
25681       {
25682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25683       };
25684     } catch (Dali::DaliException e) {
25685       {
25686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25687       };
25688     } catch (...) {
25689       {
25690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25691       };
25692     }
25693   }
25694
25695   jresult = (void *)result;
25696   return jresult;
25697 }
25698
25699
25700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
25701   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25702
25703   arg1 = (Dali::Geometry *)jarg1;
25704   {
25705     try {
25706       delete arg1;
25707     } catch (std::out_of_range& e) {
25708       {
25709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25710       };
25711     } catch (std::exception& e) {
25712       {
25713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25714       };
25715     } catch (Dali::DaliException e) {
25716       {
25717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25718       };
25719     } catch (...) {
25720       {
25721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25722       };
25723     }
25724   }
25725
25726 }
25727
25728
25729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
25730   void * jresult ;
25731   Dali::Geometry *arg1 = 0 ;
25732   Dali::Geometry *result = 0 ;
25733
25734   arg1 = (Dali::Geometry *)jarg1;
25735   if (!arg1) {
25736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25737     return 0;
25738   }
25739   {
25740     try {
25741       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
25742     } catch (std::out_of_range& e) {
25743       {
25744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25745       };
25746     } catch (std::exception& e) {
25747       {
25748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25749       };
25750     } catch (Dali::DaliException e) {
25751       {
25752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25753       };
25754     } catch (...) {
25755       {
25756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25757       };
25758     }
25759   }
25760
25761   jresult = (void *)result;
25762   return jresult;
25763 }
25764
25765
25766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
25767   void * jresult ;
25768   Dali::BaseHandle arg1 ;
25769   Dali::BaseHandle *argp1 ;
25770   Dali::Geometry result;
25771
25772   argp1 = (Dali::BaseHandle *)jarg1;
25773   if (!argp1) {
25774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25775     return 0;
25776   }
25777   arg1 = *argp1;
25778   {
25779     try {
25780       result = Dali::Geometry::DownCast(arg1);
25781     } catch (std::out_of_range& e) {
25782       {
25783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25784       };
25785     } catch (std::exception& e) {
25786       {
25787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25788       };
25789     } catch (Dali::DaliException e) {
25790       {
25791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25792       };
25793     } catch (...) {
25794       {
25795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25796       };
25797     }
25798   }
25799
25800   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25801   return jresult;
25802 }
25803
25804
25805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
25806   void * jresult ;
25807   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25808   Dali::Geometry *arg2 = 0 ;
25809   Dali::Geometry *result = 0 ;
25810
25811   arg1 = (Dali::Geometry *)jarg1;
25812   arg2 = (Dali::Geometry *)jarg2;
25813   if (!arg2) {
25814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25815     return 0;
25816   }
25817   {
25818     try {
25819       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
25820     } catch (std::out_of_range& e) {
25821       {
25822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25823       };
25824     } catch (std::exception& e) {
25825       {
25826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25827       };
25828     } catch (Dali::DaliException e) {
25829       {
25830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25831       };
25832     } catch (...) {
25833       {
25834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25835       };
25836     }
25837   }
25838
25839   jresult = (void *)result;
25840   return jresult;
25841 }
25842
25843
25844 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
25845   unsigned long jresult ;
25846   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25847   Dali::PropertyBuffer *arg2 = 0 ;
25848   std::size_t result;
25849
25850   arg1 = (Dali::Geometry *)jarg1;
25851   arg2 = (Dali::PropertyBuffer *)jarg2;
25852   if (!arg2) {
25853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
25854     return 0;
25855   }
25856   {
25857     try {
25858       result = (arg1)->AddVertexBuffer(*arg2);
25859     } catch (std::out_of_range& e) {
25860       {
25861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25862       };
25863     } catch (std::exception& e) {
25864       {
25865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25866       };
25867     } catch (Dali::DaliException e) {
25868       {
25869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25870       };
25871     } catch (...) {
25872       {
25873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25874       };
25875     }
25876   }
25877
25878   jresult = (unsigned long)result;
25879   return jresult;
25880 }
25881
25882
25883 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
25884   unsigned long jresult ;
25885   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25886   std::size_t result;
25887
25888   arg1 = (Dali::Geometry *)jarg1;
25889   {
25890     try {
25891       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
25892     } catch (std::out_of_range& e) {
25893       {
25894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25895       };
25896     } catch (std::exception& e) {
25897       {
25898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25899       };
25900     } catch (Dali::DaliException e) {
25901       {
25902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25903       };
25904     } catch (...) {
25905       {
25906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25907       };
25908     }
25909   }
25910
25911   jresult = (unsigned long)result;
25912   return jresult;
25913 }
25914
25915
25916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
25917   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25918   std::size_t arg2 ;
25919
25920   arg1 = (Dali::Geometry *)jarg1;
25921   arg2 = (std::size_t)jarg2;
25922   {
25923     try {
25924       (arg1)->RemoveVertexBuffer(arg2);
25925     } catch (std::out_of_range& e) {
25926       {
25927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25928       };
25929     } catch (std::exception& e) {
25930       {
25931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25932       };
25933     } catch (Dali::DaliException e) {
25934       {
25935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25936       };
25937     } catch (...) {
25938       {
25939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25940       };
25941     }
25942   }
25943
25944 }
25945
25946
25947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
25948   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25949   unsigned short *arg2 = (unsigned short *) 0 ;
25950   size_t arg3 ;
25951
25952   arg1 = (Dali::Geometry *)jarg1;
25953   arg2 = jarg2;
25954   arg3 = (size_t)jarg3;
25955   {
25956     try {
25957       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
25958     } catch (std::out_of_range& e) {
25959       {
25960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25961       };
25962     } catch (std::exception& e) {
25963       {
25964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25965       };
25966     } catch (Dali::DaliException e) {
25967       {
25968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25969       };
25970     } catch (...) {
25971       {
25972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25973       };
25974     }
25975   }
25976
25977
25978
25979 }
25980
25981
25982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
25983   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25984   Dali::Geometry::Type arg2 ;
25985
25986   arg1 = (Dali::Geometry *)jarg1;
25987   arg2 = (Dali::Geometry::Type)jarg2;
25988   {
25989     try {
25990       (arg1)->SetType(arg2);
25991     } catch (std::out_of_range& e) {
25992       {
25993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25994       };
25995     } catch (std::exception& e) {
25996       {
25997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25998       };
25999     } catch (Dali::DaliException e) {
26000       {
26001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26002       };
26003     } catch (...) {
26004       {
26005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26006       };
26007     }
26008   }
26009
26010 }
26011
26012
26013 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
26014   int jresult ;
26015   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26016   Dali::Geometry::Type result;
26017
26018   arg1 = (Dali::Geometry *)jarg1;
26019   {
26020     try {
26021       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
26022     } catch (std::out_of_range& e) {
26023       {
26024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26025       };
26026     } catch (std::exception& e) {
26027       {
26028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26029       };
26030     } catch (Dali::DaliException e) {
26031       {
26032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26033       };
26034     } catch (...) {
26035       {
26036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26037       };
26038     }
26039   }
26040
26041   jresult = (int)result;
26042   return jresult;
26043 }
26044
26045
26046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
26047   void * jresult ;
26048   Dali::Shader::Hint *result = 0 ;
26049
26050   {
26051     try {
26052       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
26053     } catch (std::out_of_range& e) {
26054       {
26055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26056       };
26057     } catch (std::exception& e) {
26058       {
26059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26060       };
26061     } catch (Dali::DaliException e) {
26062       {
26063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26064       };
26065     } catch (...) {
26066       {
26067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26068       };
26069     }
26070   }
26071
26072   jresult = (void *)result;
26073   return jresult;
26074 }
26075
26076
26077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
26078   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
26079
26080   arg1 = (Dali::Shader::Hint *)jarg1;
26081   {
26082     try {
26083       delete arg1;
26084     } catch (std::out_of_range& e) {
26085       {
26086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26087       };
26088     } catch (std::exception& e) {
26089       {
26090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26091       };
26092     } catch (Dali::DaliException e) {
26093       {
26094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26095       };
26096     } catch (...) {
26097       {
26098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26099       };
26100     }
26101   }
26102
26103 }
26104
26105
26106 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
26107   int jresult ;
26108   int result;
26109
26110   result = (int)Dali::Shader::Property::PROGRAM;
26111   jresult = (int)result;
26112   return jresult;
26113 }
26114
26115
26116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
26117   void * jresult ;
26118   Dali::Shader::Property *result = 0 ;
26119
26120   {
26121     try {
26122       result = (Dali::Shader::Property *)new Dali::Shader::Property();
26123     } catch (std::out_of_range& e) {
26124       {
26125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26126       };
26127     } catch (std::exception& e) {
26128       {
26129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26130       };
26131     } catch (Dali::DaliException e) {
26132       {
26133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26134       };
26135     } catch (...) {
26136       {
26137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26138       };
26139     }
26140   }
26141
26142   jresult = (void *)result;
26143   return jresult;
26144 }
26145
26146
26147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
26148   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
26149
26150   arg1 = (Dali::Shader::Property *)jarg1;
26151   {
26152     try {
26153       delete arg1;
26154     } catch (std::out_of_range& e) {
26155       {
26156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26157       };
26158     } catch (std::exception& e) {
26159       {
26160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26161       };
26162     } catch (Dali::DaliException e) {
26163       {
26164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26165       };
26166     } catch (...) {
26167       {
26168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26169       };
26170     }
26171   }
26172
26173 }
26174
26175
26176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
26177   void * jresult ;
26178   std::string *arg1 = 0 ;
26179   std::string *arg2 = 0 ;
26180   Dali::Shader::Hint::Value arg3 ;
26181   Dali::Shader result;
26182
26183   if (!jarg1) {
26184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26185     return 0;
26186   }
26187   std::string arg1_str(jarg1);
26188   arg1 = &arg1_str;
26189   if (!jarg2) {
26190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26191     return 0;
26192   }
26193   std::string arg2_str(jarg2);
26194   arg2 = &arg2_str;
26195   arg3 = (Dali::Shader::Hint::Value)jarg3;
26196   {
26197     try {
26198       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
26199     } catch (std::out_of_range& e) {
26200       {
26201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26202       };
26203     } catch (std::exception& e) {
26204       {
26205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26206       };
26207     } catch (Dali::DaliException e) {
26208       {
26209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26210       };
26211     } catch (...) {
26212       {
26213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26214       };
26215     }
26216   }
26217
26218   jresult = new Dali::Shader((const Dali::Shader &)result);
26219
26220   //argout typemap for const std::string&
26221
26222
26223   //argout typemap for const std::string&
26224
26225   return jresult;
26226 }
26227
26228
26229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
26230   void * jresult ;
26231   std::string *arg1 = 0 ;
26232   std::string *arg2 = 0 ;
26233   Dali::Shader result;
26234
26235   if (!jarg1) {
26236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26237     return 0;
26238   }
26239   std::string arg1_str(jarg1);
26240   arg1 = &arg1_str;
26241   if (!jarg2) {
26242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26243     return 0;
26244   }
26245   std::string arg2_str(jarg2);
26246   arg2 = &arg2_str;
26247   {
26248     try {
26249       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
26250     } catch (std::out_of_range& e) {
26251       {
26252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26253       };
26254     } catch (std::exception& e) {
26255       {
26256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26257       };
26258     } catch (Dali::DaliException e) {
26259       {
26260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26261       };
26262     } catch (...) {
26263       {
26264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26265       };
26266     }
26267   }
26268
26269   jresult = new Dali::Shader((const Dali::Shader &)result);
26270
26271   //argout typemap for const std::string&
26272
26273
26274   //argout typemap for const std::string&
26275
26276   return jresult;
26277 }
26278
26279
26280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
26281   void * jresult ;
26282   Dali::Shader *result = 0 ;
26283
26284   {
26285     try {
26286       result = (Dali::Shader *)new Dali::Shader();
26287     } catch (std::out_of_range& e) {
26288       {
26289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26290       };
26291     } catch (std::exception& e) {
26292       {
26293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26294       };
26295     } catch (Dali::DaliException e) {
26296       {
26297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26298       };
26299     } catch (...) {
26300       {
26301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26302       };
26303     }
26304   }
26305
26306   jresult = (void *)result;
26307   return jresult;
26308 }
26309
26310
26311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
26312   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26313
26314   arg1 = (Dali::Shader *)jarg1;
26315   {
26316     try {
26317       delete arg1;
26318     } catch (std::out_of_range& e) {
26319       {
26320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26321       };
26322     } catch (std::exception& e) {
26323       {
26324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26325       };
26326     } catch (Dali::DaliException e) {
26327       {
26328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26329       };
26330     } catch (...) {
26331       {
26332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26333       };
26334     }
26335   }
26336
26337 }
26338
26339
26340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
26341   void * jresult ;
26342   Dali::Shader *arg1 = 0 ;
26343   Dali::Shader *result = 0 ;
26344
26345   arg1 = (Dali::Shader *)jarg1;
26346   if (!arg1) {
26347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26348     return 0;
26349   }
26350   {
26351     try {
26352       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
26353     } catch (std::out_of_range& e) {
26354       {
26355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26356       };
26357     } catch (std::exception& e) {
26358       {
26359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26360       };
26361     } catch (Dali::DaliException e) {
26362       {
26363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26364       };
26365     } catch (...) {
26366       {
26367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26368       };
26369     }
26370   }
26371
26372   jresult = (void *)result;
26373   return jresult;
26374 }
26375
26376
26377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
26378   void * jresult ;
26379   Dali::BaseHandle arg1 ;
26380   Dali::BaseHandle *argp1 ;
26381   Dali::Shader result;
26382
26383   argp1 = (Dali::BaseHandle *)jarg1;
26384   if (!argp1) {
26385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26386     return 0;
26387   }
26388   arg1 = *argp1;
26389   {
26390     try {
26391       result = Dali::Shader::DownCast(arg1);
26392     } catch (std::out_of_range& e) {
26393       {
26394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26395       };
26396     } catch (std::exception& e) {
26397       {
26398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26399       };
26400     } catch (Dali::DaliException e) {
26401       {
26402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26403       };
26404     } catch (...) {
26405       {
26406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26407       };
26408     }
26409   }
26410
26411   jresult = new Dali::Shader((const Dali::Shader &)result);
26412   return jresult;
26413 }
26414
26415
26416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
26417   void * jresult ;
26418   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26419   Dali::Shader *arg2 = 0 ;
26420   Dali::Shader *result = 0 ;
26421
26422   arg1 = (Dali::Shader *)jarg1;
26423   arg2 = (Dali::Shader *)jarg2;
26424   if (!arg2) {
26425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26426     return 0;
26427   }
26428   {
26429     try {
26430       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
26431     } catch (std::out_of_range& e) {
26432       {
26433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26434       };
26435     } catch (std::exception& e) {
26436       {
26437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26438       };
26439     } catch (Dali::DaliException e) {
26440       {
26441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26442       };
26443     } catch (...) {
26444       {
26445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26446       };
26447     }
26448   }
26449
26450   jresult = (void *)result;
26451   return jresult;
26452 }
26453
26454
26455 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
26456   int jresult ;
26457   int result;
26458
26459   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
26460   jresult = (int)result;
26461   return jresult;
26462 }
26463
26464
26465 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
26466   int jresult ;
26467   int result;
26468
26469   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
26470   jresult = (int)result;
26471   return jresult;
26472 }
26473
26474
26475 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
26476   int jresult ;
26477   int result;
26478
26479   result = (int)Dali::Renderer::Property::BLEND_MODE;
26480   jresult = (int)result;
26481   return jresult;
26482 }
26483
26484
26485 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
26486   int jresult ;
26487   int result;
26488
26489   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
26490   jresult = (int)result;
26491   return jresult;
26492 }
26493
26494
26495 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
26496   int jresult ;
26497   int result;
26498
26499   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
26500   jresult = (int)result;
26501   return jresult;
26502 }
26503
26504
26505 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
26506   int jresult ;
26507   int result;
26508
26509   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
26510   jresult = (int)result;
26511   return jresult;
26512 }
26513
26514
26515 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
26516   int jresult ;
26517   int result;
26518
26519   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
26520   jresult = (int)result;
26521   return jresult;
26522 }
26523
26524
26525 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
26526   int jresult ;
26527   int result;
26528
26529   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
26530   jresult = (int)result;
26531   return jresult;
26532 }
26533
26534
26535 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
26536   int jresult ;
26537   int result;
26538
26539   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
26540   jresult = (int)result;
26541   return jresult;
26542 }
26543
26544
26545 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
26546   int jresult ;
26547   int result;
26548
26549   result = (int)Dali::Renderer::Property::BLEND_COLOR;
26550   jresult = (int)result;
26551   return jresult;
26552 }
26553
26554
26555 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
26556   int jresult ;
26557   int result;
26558
26559   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
26560   jresult = (int)result;
26561   return jresult;
26562 }
26563
26564
26565 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
26566   int jresult ;
26567   int result;
26568
26569   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
26570   jresult = (int)result;
26571   return jresult;
26572 }
26573
26574
26575 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
26576   int jresult ;
26577   int result;
26578
26579   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
26580   jresult = (int)result;
26581   return jresult;
26582 }
26583
26584
26585 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
26586   int jresult ;
26587   int result;
26588
26589   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
26590   jresult = (int)result;
26591   return jresult;
26592 }
26593
26594
26595 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
26596   int jresult ;
26597   int result;
26598
26599   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
26600   jresult = (int)result;
26601   return jresult;
26602 }
26603
26604
26605 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
26606   int jresult ;
26607   int result;
26608
26609   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
26610   jresult = (int)result;
26611   return jresult;
26612 }
26613
26614
26615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
26616   int jresult ;
26617   int result;
26618
26619   result = (int)Dali::Renderer::Property::RENDER_MODE;
26620   jresult = (int)result;
26621   return jresult;
26622 }
26623
26624
26625 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
26626   int jresult ;
26627   int result;
26628
26629   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
26630   jresult = (int)result;
26631   return jresult;
26632 }
26633
26634
26635 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
26636   int jresult ;
26637   int result;
26638
26639   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
26640   jresult = (int)result;
26641   return jresult;
26642 }
26643
26644
26645 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
26646   int jresult ;
26647   int result;
26648
26649   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
26650   jresult = (int)result;
26651   return jresult;
26652 }
26653
26654
26655 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
26656   int jresult ;
26657   int result;
26658
26659   result = (int)Dali::Renderer::Property::STENCIL_MASK;
26660   jresult = (int)result;
26661   return jresult;
26662 }
26663
26664
26665 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
26666   int jresult ;
26667   int result;
26668
26669   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
26670   jresult = (int)result;
26671   return jresult;
26672 }
26673
26674
26675 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
26676   int jresult ;
26677   int result;
26678
26679   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
26680   jresult = (int)result;
26681   return jresult;
26682 }
26683
26684
26685 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
26686   int jresult ;
26687   int result;
26688
26689   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
26690   jresult = (int)result;
26691   return jresult;
26692 }
26693
26694
26695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
26696   void * jresult ;
26697   Dali::Renderer::Property *result = 0 ;
26698
26699   {
26700     try {
26701       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
26702     } catch (std::out_of_range& e) {
26703       {
26704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26705       };
26706     } catch (std::exception& e) {
26707       {
26708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26709       };
26710     } catch (Dali::DaliException e) {
26711       {
26712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26713       };
26714     } catch (...) {
26715       {
26716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26717       };
26718     }
26719   }
26720
26721   jresult = (void *)result;
26722   return jresult;
26723 }
26724
26725
26726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
26727   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
26728
26729   arg1 = (Dali::Renderer::Property *)jarg1;
26730   {
26731     try {
26732       delete arg1;
26733     } catch (std::out_of_range& e) {
26734       {
26735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26736       };
26737     } catch (std::exception& e) {
26738       {
26739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26740       };
26741     } catch (Dali::DaliException e) {
26742       {
26743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26744       };
26745     } catch (...) {
26746       {
26747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26748       };
26749     }
26750   }
26751
26752 }
26753
26754
26755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
26756   void * jresult ;
26757   Dali::Geometry *arg1 = 0 ;
26758   Dali::Shader *arg2 = 0 ;
26759   Dali::Renderer result;
26760
26761   arg1 = (Dali::Geometry *)jarg1;
26762   if (!arg1) {
26763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26764     return 0;
26765   }
26766   arg2 = (Dali::Shader *)jarg2;
26767   if (!arg2) {
26768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
26769     return 0;
26770   }
26771   {
26772     try {
26773       result = Dali::Renderer::New(*arg1,*arg2);
26774     } catch (std::out_of_range& e) {
26775       {
26776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26777       };
26778     } catch (std::exception& e) {
26779       {
26780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26781       };
26782     } catch (Dali::DaliException e) {
26783       {
26784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26785       };
26786     } catch (...) {
26787       {
26788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26789       };
26790     }
26791   }
26792
26793   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26794   return jresult;
26795 }
26796
26797
26798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
26799   void * jresult ;
26800   Dali::Renderer *result = 0 ;
26801
26802   {
26803     try {
26804       result = (Dali::Renderer *)new Dali::Renderer();
26805     } catch (std::out_of_range& e) {
26806       {
26807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26808       };
26809     } catch (std::exception& e) {
26810       {
26811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26812       };
26813     } catch (Dali::DaliException e) {
26814       {
26815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26816       };
26817     } catch (...) {
26818       {
26819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26820       };
26821     }
26822   }
26823
26824   jresult = (void *)result;
26825   return jresult;
26826 }
26827
26828
26829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
26830   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26831
26832   arg1 = (Dali::Renderer *)jarg1;
26833   {
26834     try {
26835       delete arg1;
26836     } catch (std::out_of_range& e) {
26837       {
26838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26839       };
26840     } catch (std::exception& e) {
26841       {
26842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26843       };
26844     } catch (Dali::DaliException e) {
26845       {
26846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26847       };
26848     } catch (...) {
26849       {
26850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26851       };
26852     }
26853   }
26854
26855 }
26856
26857
26858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
26859   void * jresult ;
26860   Dali::Renderer *arg1 = 0 ;
26861   Dali::Renderer *result = 0 ;
26862
26863   arg1 = (Dali::Renderer *)jarg1;
26864   if (!arg1) {
26865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26866     return 0;
26867   }
26868   {
26869     try {
26870       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
26871     } catch (std::out_of_range& e) {
26872       {
26873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26874       };
26875     } catch (std::exception& e) {
26876       {
26877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26878       };
26879     } catch (Dali::DaliException e) {
26880       {
26881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26882       };
26883     } catch (...) {
26884       {
26885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26886       };
26887     }
26888   }
26889
26890   jresult = (void *)result;
26891   return jresult;
26892 }
26893
26894
26895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
26896   void * jresult ;
26897   Dali::BaseHandle arg1 ;
26898   Dali::BaseHandle *argp1 ;
26899   Dali::Renderer result;
26900
26901   argp1 = (Dali::BaseHandle *)jarg1;
26902   if (!argp1) {
26903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26904     return 0;
26905   }
26906   arg1 = *argp1;
26907   {
26908     try {
26909       result = Dali::Renderer::DownCast(arg1);
26910     } catch (std::out_of_range& e) {
26911       {
26912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26913       };
26914     } catch (std::exception& e) {
26915       {
26916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26917       };
26918     } catch (Dali::DaliException e) {
26919       {
26920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26921       };
26922     } catch (...) {
26923       {
26924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26925       };
26926     }
26927   }
26928
26929   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26930   return jresult;
26931 }
26932
26933
26934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
26935   void * jresult ;
26936   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26937   Dali::Renderer *arg2 = 0 ;
26938   Dali::Renderer *result = 0 ;
26939
26940   arg1 = (Dali::Renderer *)jarg1;
26941   arg2 = (Dali::Renderer *)jarg2;
26942   if (!arg2) {
26943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26944     return 0;
26945   }
26946   {
26947     try {
26948       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
26949     } catch (std::out_of_range& e) {
26950       {
26951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26952       };
26953     } catch (std::exception& e) {
26954       {
26955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26956       };
26957     } catch (Dali::DaliException e) {
26958       {
26959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26960       };
26961     } catch (...) {
26962       {
26963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26964       };
26965     }
26966   }
26967
26968   jresult = (void *)result;
26969   return jresult;
26970 }
26971
26972
26973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
26974   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26975   Dali::Geometry *arg2 = 0 ;
26976
26977   arg1 = (Dali::Renderer *)jarg1;
26978   arg2 = (Dali::Geometry *)jarg2;
26979   if (!arg2) {
26980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26981     return ;
26982   }
26983   {
26984     try {
26985       (arg1)->SetGeometry(*arg2);
26986     } catch (std::out_of_range& e) {
26987       {
26988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26989       };
26990     } catch (std::exception& e) {
26991       {
26992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26993       };
26994     } catch (Dali::DaliException e) {
26995       {
26996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26997       };
26998     } catch (...) {
26999       {
27000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27001       };
27002     }
27003   }
27004
27005 }
27006
27007
27008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
27009   void * jresult ;
27010   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27011   Dali::Geometry result;
27012
27013   arg1 = (Dali::Renderer *)jarg1;
27014   {
27015     try {
27016       result = ((Dali::Renderer const *)arg1)->GetGeometry();
27017     } catch (std::out_of_range& e) {
27018       {
27019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27020       };
27021     } catch (std::exception& e) {
27022       {
27023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27024       };
27025     } catch (Dali::DaliException e) {
27026       {
27027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27028       };
27029     } catch (...) {
27030       {
27031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27032       };
27033     }
27034   }
27035
27036   jresult = new Dali::Geometry((const Dali::Geometry &)result);
27037   return jresult;
27038 }
27039
27040
27041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
27042   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27043   int arg2 ;
27044   int arg3 ;
27045
27046   arg1 = (Dali::Renderer *)jarg1;
27047   arg2 = (int)jarg2;
27048   arg3 = (int)jarg3;
27049   {
27050     try {
27051       (arg1)->SetIndexRange(arg2,arg3);
27052     } catch (std::out_of_range& e) {
27053       {
27054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27055       };
27056     } catch (std::exception& e) {
27057       {
27058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27059       };
27060     } catch (Dali::DaliException e) {
27061       {
27062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27063       };
27064     } catch (...) {
27065       {
27066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27067       };
27068     }
27069   }
27070
27071 }
27072
27073
27074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
27075   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27076   Dali::TextureSet *arg2 = 0 ;
27077
27078   arg1 = (Dali::Renderer *)jarg1;
27079   arg2 = (Dali::TextureSet *)jarg2;
27080   if (!arg2) {
27081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
27082     return ;
27083   }
27084   {
27085     try {
27086       (arg1)->SetTextures(*arg2);
27087     } catch (std::out_of_range& e) {
27088       {
27089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27090       };
27091     } catch (std::exception& e) {
27092       {
27093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27094       };
27095     } catch (Dali::DaliException e) {
27096       {
27097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27098       };
27099     } catch (...) {
27100       {
27101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27102       };
27103     }
27104   }
27105
27106 }
27107
27108
27109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
27110   void * jresult ;
27111   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27112   Dali::TextureSet result;
27113
27114   arg1 = (Dali::Renderer *)jarg1;
27115   {
27116     try {
27117       result = ((Dali::Renderer const *)arg1)->GetTextures();
27118     } catch (std::out_of_range& e) {
27119       {
27120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27121       };
27122     } catch (std::exception& e) {
27123       {
27124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27125       };
27126     } catch (Dali::DaliException e) {
27127       {
27128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27129       };
27130     } catch (...) {
27131       {
27132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27133       };
27134     }
27135   }
27136
27137   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
27138   return jresult;
27139 }
27140
27141
27142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
27143   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27144   Dali::Shader *arg2 = 0 ;
27145
27146   arg1 = (Dali::Renderer *)jarg1;
27147   arg2 = (Dali::Shader *)jarg2;
27148   if (!arg2) {
27149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
27150     return ;
27151   }
27152   {
27153     try {
27154       (arg1)->SetShader(*arg2);
27155     } catch (std::out_of_range& e) {
27156       {
27157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27158       };
27159     } catch (std::exception& e) {
27160       {
27161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27162       };
27163     } catch (Dali::DaliException e) {
27164       {
27165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27166       };
27167     } catch (...) {
27168       {
27169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27170       };
27171     }
27172   }
27173
27174 }
27175
27176
27177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
27178   void * jresult ;
27179   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27180   Dali::Shader result;
27181
27182   arg1 = (Dali::Renderer *)jarg1;
27183   {
27184     try {
27185       result = ((Dali::Renderer const *)arg1)->GetShader();
27186     } catch (std::out_of_range& e) {
27187       {
27188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27189       };
27190     } catch (std::exception& e) {
27191       {
27192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27193       };
27194     } catch (Dali::DaliException e) {
27195       {
27196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27197       };
27198     } catch (...) {
27199       {
27200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27201       };
27202     }
27203   }
27204
27205   jresult = new Dali::Shader((const Dali::Shader &)result);
27206   return jresult;
27207 }
27208
27209
27210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
27211   void * jresult ;
27212   Dali::FrameBuffer::Attachment *result = 0 ;
27213
27214   {
27215     try {
27216       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
27217     } catch (std::out_of_range& e) {
27218       {
27219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27220       };
27221     } catch (std::exception& e) {
27222       {
27223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27224       };
27225     } catch (Dali::DaliException e) {
27226       {
27227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27228       };
27229     } catch (...) {
27230       {
27231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27232       };
27233     }
27234   }
27235
27236   jresult = (void *)result;
27237   return jresult;
27238 }
27239
27240
27241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
27242   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
27243
27244   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
27245   {
27246     try {
27247       delete arg1;
27248     } catch (std::out_of_range& e) {
27249       {
27250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27251       };
27252     } catch (std::exception& e) {
27253       {
27254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27255       };
27256     } catch (Dali::DaliException e) {
27257       {
27258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27259       };
27260     } catch (...) {
27261       {
27262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27263       };
27264     }
27265   }
27266
27267 }
27268
27269
27270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
27271   void * jresult ;
27272   unsigned int arg1 ;
27273   unsigned int arg2 ;
27274   unsigned int arg3 ;
27275   Dali::FrameBuffer result;
27276
27277   arg1 = (unsigned int)jarg1;
27278   arg2 = (unsigned int)jarg2;
27279   arg3 = (unsigned int)jarg3;
27280   {
27281     try {
27282       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
27283     } catch (std::out_of_range& e) {
27284       {
27285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27286       };
27287     } catch (std::exception& e) {
27288       {
27289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27290       };
27291     } catch (Dali::DaliException e) {
27292       {
27293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27294       };
27295     } catch (...) {
27296       {
27297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27298       };
27299     }
27300   }
27301
27302   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27303   return jresult;
27304 }
27305
27306
27307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
27308   void * jresult ;
27309   Dali::FrameBuffer *result = 0 ;
27310
27311   {
27312     try {
27313       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
27314     } catch (std::out_of_range& e) {
27315       {
27316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27317       };
27318     } catch (std::exception& e) {
27319       {
27320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27321       };
27322     } catch (Dali::DaliException e) {
27323       {
27324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27325       };
27326     } catch (...) {
27327       {
27328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27329       };
27330     }
27331   }
27332
27333   jresult = (void *)result;
27334   return jresult;
27335 }
27336
27337
27338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
27339   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27340
27341   arg1 = (Dali::FrameBuffer *)jarg1;
27342   {
27343     try {
27344       delete arg1;
27345     } catch (std::out_of_range& e) {
27346       {
27347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27348       };
27349     } catch (std::exception& e) {
27350       {
27351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27352       };
27353     } catch (Dali::DaliException e) {
27354       {
27355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27356       };
27357     } catch (...) {
27358       {
27359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27360       };
27361     }
27362   }
27363
27364 }
27365
27366
27367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
27368   void * jresult ;
27369   Dali::FrameBuffer *arg1 = 0 ;
27370   Dali::FrameBuffer *result = 0 ;
27371
27372   arg1 = (Dali::FrameBuffer *)jarg1;
27373   if (!arg1) {
27374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27375     return 0;
27376   }
27377   {
27378     try {
27379       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
27380     } catch (std::out_of_range& e) {
27381       {
27382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27383       };
27384     } catch (std::exception& e) {
27385       {
27386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27387       };
27388     } catch (Dali::DaliException e) {
27389       {
27390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27391       };
27392     } catch (...) {
27393       {
27394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27395       };
27396     }
27397   }
27398
27399   jresult = (void *)result;
27400   return jresult;
27401 }
27402
27403
27404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
27405   void * jresult ;
27406   Dali::BaseHandle arg1 ;
27407   Dali::BaseHandle *argp1 ;
27408   Dali::FrameBuffer result;
27409
27410   argp1 = (Dali::BaseHandle *)jarg1;
27411   if (!argp1) {
27412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27413     return 0;
27414   }
27415   arg1 = *argp1;
27416   {
27417     try {
27418       result = Dali::FrameBuffer::DownCast(arg1);
27419     } catch (std::out_of_range& e) {
27420       {
27421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27422       };
27423     } catch (std::exception& e) {
27424       {
27425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27426       };
27427     } catch (Dali::DaliException e) {
27428       {
27429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27430       };
27431     } catch (...) {
27432       {
27433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27434       };
27435     }
27436   }
27437
27438   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27439   return jresult;
27440 }
27441
27442
27443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
27444   void * jresult ;
27445   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27446   Dali::FrameBuffer *arg2 = 0 ;
27447   Dali::FrameBuffer *result = 0 ;
27448
27449   arg1 = (Dali::FrameBuffer *)jarg1;
27450   arg2 = (Dali::FrameBuffer *)jarg2;
27451   if (!arg2) {
27452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27453     return 0;
27454   }
27455   {
27456     try {
27457       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
27458     } catch (std::out_of_range& e) {
27459       {
27460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27461       };
27462     } catch (std::exception& e) {
27463       {
27464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27465       };
27466     } catch (Dali::DaliException e) {
27467       {
27468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27469       };
27470     } catch (...) {
27471       {
27472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27473       };
27474     }
27475   }
27476
27477   jresult = (void *)result;
27478   return jresult;
27479 }
27480
27481
27482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
27483   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27484   Dali::Texture *arg2 = 0 ;
27485
27486   arg1 = (Dali::FrameBuffer *)jarg1;
27487   arg2 = (Dali::Texture *)jarg2;
27488   if (!arg2) {
27489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27490     return ;
27491   }
27492   {
27493     try {
27494       (arg1)->AttachColorTexture(*arg2);
27495     } catch (std::out_of_range& e) {
27496       {
27497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27498       };
27499     } catch (std::exception& e) {
27500       {
27501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27502       };
27503     } catch (Dali::DaliException e) {
27504       {
27505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27506       };
27507     } catch (...) {
27508       {
27509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27510       };
27511     }
27512   }
27513
27514 }
27515
27516
27517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
27518   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27519   Dali::Texture *arg2 = 0 ;
27520   unsigned int arg3 ;
27521   unsigned int arg4 ;
27522
27523   arg1 = (Dali::FrameBuffer *)jarg1;
27524   arg2 = (Dali::Texture *)jarg2;
27525   if (!arg2) {
27526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27527     return ;
27528   }
27529   arg3 = (unsigned int)jarg3;
27530   arg4 = (unsigned int)jarg4;
27531   {
27532     try {
27533       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
27534     } catch (std::out_of_range& e) {
27535       {
27536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27537       };
27538     } catch (std::exception& e) {
27539       {
27540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27541       };
27542     } catch (Dali::DaliException e) {
27543       {
27544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27545       };
27546     } catch (...) {
27547       {
27548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27549       };
27550     }
27551   }
27552
27553 }
27554
27555
27556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
27557   void * jresult ;
27558   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27559   Dali::Texture result;
27560
27561   arg1 = (Dali::FrameBuffer *)jarg1;
27562   {
27563     try {
27564       result = (arg1)->GetColorTexture();
27565     } catch (std::out_of_range& e) {
27566       {
27567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27568       };
27569     } catch (std::exception& e) {
27570       {
27571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27572       };
27573     } catch (Dali::DaliException e) {
27574       {
27575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27576       };
27577     } catch (...) {
27578       {
27579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27580       };
27581     }
27582   }
27583
27584   jresult = new Dali::Texture((const Dali::Texture &)result);
27585   return jresult;
27586 }
27587
27588
27589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
27590   void * jresult ;
27591   Dali::RenderTaskList *result = 0 ;
27592
27593   {
27594     try {
27595       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
27596     } catch (std::out_of_range& e) {
27597       {
27598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27599       };
27600     } catch (std::exception& e) {
27601       {
27602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27603       };
27604     } catch (Dali::DaliException e) {
27605       {
27606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27607       };
27608     } catch (...) {
27609       {
27610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27611       };
27612     }
27613   }
27614
27615   jresult = (void *)result;
27616   return jresult;
27617 }
27618
27619
27620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
27621   void * jresult ;
27622   Dali::BaseHandle arg1 ;
27623   Dali::BaseHandle *argp1 ;
27624   Dali::RenderTaskList result;
27625
27626   argp1 = (Dali::BaseHandle *)jarg1;
27627   if (!argp1) {
27628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27629     return 0;
27630   }
27631   arg1 = *argp1;
27632   {
27633     try {
27634       result = Dali::RenderTaskList::DownCast(arg1);
27635     } catch (std::out_of_range& e) {
27636       {
27637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27638       };
27639     } catch (std::exception& e) {
27640       {
27641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27642       };
27643     } catch (Dali::DaliException e) {
27644       {
27645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27646       };
27647     } catch (...) {
27648       {
27649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27650       };
27651     }
27652   }
27653
27654   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
27655   return jresult;
27656 }
27657
27658
27659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
27660   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27661
27662   arg1 = (Dali::RenderTaskList *)jarg1;
27663   {
27664     try {
27665       delete arg1;
27666     } catch (std::out_of_range& e) {
27667       {
27668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27669       };
27670     } catch (std::exception& e) {
27671       {
27672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27673       };
27674     } catch (Dali::DaliException e) {
27675       {
27676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27677       };
27678     } catch (...) {
27679       {
27680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27681       };
27682     }
27683   }
27684
27685 }
27686
27687
27688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
27689   void * jresult ;
27690   Dali::RenderTaskList *arg1 = 0 ;
27691   Dali::RenderTaskList *result = 0 ;
27692
27693   arg1 = (Dali::RenderTaskList *)jarg1;
27694   if (!arg1) {
27695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27696     return 0;
27697   }
27698   {
27699     try {
27700       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
27701     } catch (std::out_of_range& e) {
27702       {
27703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27704       };
27705     } catch (std::exception& e) {
27706       {
27707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27708       };
27709     } catch (Dali::DaliException e) {
27710       {
27711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27712       };
27713     } catch (...) {
27714       {
27715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27716       };
27717     }
27718   }
27719
27720   jresult = (void *)result;
27721   return jresult;
27722 }
27723
27724
27725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
27726   void * jresult ;
27727   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27728   Dali::RenderTaskList *arg2 = 0 ;
27729   Dali::RenderTaskList *result = 0 ;
27730
27731   arg1 = (Dali::RenderTaskList *)jarg1;
27732   arg2 = (Dali::RenderTaskList *)jarg2;
27733   if (!arg2) {
27734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27735     return 0;
27736   }
27737   {
27738     try {
27739       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
27740     } catch (std::out_of_range& e) {
27741       {
27742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27743       };
27744     } catch (std::exception& e) {
27745       {
27746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27747       };
27748     } catch (Dali::DaliException e) {
27749       {
27750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27751       };
27752     } catch (...) {
27753       {
27754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27755       };
27756     }
27757   }
27758
27759   jresult = (void *)result;
27760   return jresult;
27761 }
27762
27763
27764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
27765   void * jresult ;
27766   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27767   Dali::RenderTask result;
27768
27769   arg1 = (Dali::RenderTaskList *)jarg1;
27770   {
27771     try {
27772       result = (arg1)->CreateTask();
27773     } catch (std::out_of_range& e) {
27774       {
27775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27776       };
27777     } catch (std::exception& e) {
27778       {
27779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27780       };
27781     } catch (Dali::DaliException e) {
27782       {
27783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27784       };
27785     } catch (...) {
27786       {
27787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27788       };
27789     }
27790   }
27791
27792   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27793   return jresult;
27794 }
27795
27796
27797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
27798   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27799   Dali::RenderTask arg2 ;
27800   Dali::RenderTask *argp2 ;
27801
27802   arg1 = (Dali::RenderTaskList *)jarg1;
27803   argp2 = (Dali::RenderTask *)jarg2;
27804   if (!argp2) {
27805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
27806     return ;
27807   }
27808   arg2 = *argp2;
27809   {
27810     try {
27811       (arg1)->RemoveTask(arg2);
27812     } catch (std::out_of_range& e) {
27813       {
27814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27815       };
27816     } catch (std::exception& e) {
27817       {
27818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27819       };
27820     } catch (Dali::DaliException e) {
27821       {
27822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27823       };
27824     } catch (...) {
27825       {
27826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27827       };
27828     }
27829   }
27830
27831 }
27832
27833
27834 //// ===============================================end part 1 =================
27835
27836 //// ========================= part 2 ===============================
27837
27838 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
27839   unsigned int jresult ;
27840   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27841   unsigned int result;
27842
27843   arg1 = (Dali::RenderTaskList *)jarg1;
27844   {
27845     try {
27846       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
27847     } catch (std::out_of_range& e) {
27848       {
27849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27850       };
27851     } catch (std::exception& e) {
27852       {
27853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27854       };
27855     } catch (Dali::DaliException e) {
27856       {
27857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27858       };
27859     } catch (...) {
27860       {
27861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27862       };
27863     }
27864   }
27865
27866   jresult = result;
27867   return jresult;
27868 }
27869
27870
27871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
27872   void * jresult ;
27873   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27874   unsigned int arg2 ;
27875   Dali::RenderTask result;
27876
27877   arg1 = (Dali::RenderTaskList *)jarg1;
27878   arg2 = (unsigned int)jarg2;
27879   {
27880     try {
27881       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
27882     } catch (std::out_of_range& e) {
27883       {
27884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27885       };
27886     } catch (std::exception& e) {
27887       {
27888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27889       };
27890     } catch (Dali::DaliException e) {
27891       {
27892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27893       };
27894     } catch (...) {
27895       {
27896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27897       };
27898     }
27899   }
27900
27901   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27902   return jresult;
27903 }
27904
27905
27906 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
27907   int jresult ;
27908   int result;
27909
27910   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
27911   jresult = (int)result;
27912   return jresult;
27913 }
27914
27915
27916 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
27917   int jresult ;
27918   int result;
27919
27920   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
27921   jresult = (int)result;
27922   return jresult;
27923 }
27924
27925
27926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
27927   int jresult ;
27928   int result;
27929
27930   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
27931   jresult = (int)result;
27932   return jresult;
27933 }
27934
27935
27936 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
27937   int jresult ;
27938   int result;
27939
27940   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
27941   jresult = (int)result;
27942   return jresult;
27943 }
27944
27945
27946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
27947   void * jresult ;
27948   Dali::RenderTask::Property *result = 0 ;
27949
27950   {
27951     try {
27952       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
27953     } catch (std::out_of_range& e) {
27954       {
27955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27956       };
27957     } catch (std::exception& e) {
27958       {
27959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27960       };
27961     } catch (Dali::DaliException e) {
27962       {
27963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27964       };
27965     } catch (...) {
27966       {
27967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27968       };
27969     }
27970   }
27971
27972   jresult = (void *)result;
27973   return jresult;
27974 }
27975
27976
27977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
27978   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
27979
27980   arg1 = (Dali::RenderTask::Property *)jarg1;
27981   {
27982     try {
27983       delete arg1;
27984     } catch (std::out_of_range& e) {
27985       {
27986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27987       };
27988     } catch (std::exception& e) {
27989       {
27990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27991       };
27992     } catch (Dali::DaliException e) {
27993       {
27994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27995       };
27996     } catch (...) {
27997       {
27998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27999       };
28000     }
28001   }
28002
28003 }
28004
28005
28006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
28007   void * jresult ;
28008   bool (*result)(Dali::Vector2 &) = 0 ;
28009
28010   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
28011   jresult = (void *)result;
28012   return jresult;
28013 }
28014
28015
28016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
28017   void * jresult ;
28018   bool (*result)(Dali::Vector2 &) = 0 ;
28019
28020   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
28021   jresult = (void *)result;
28022   return jresult;
28023 }
28024
28025
28026 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
28027   unsigned int jresult ;
28028   bool result;
28029
28030   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
28031   jresult = result;
28032   return jresult;
28033 }
28034
28035
28036 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
28037   unsigned int jresult ;
28038   bool result;
28039
28040   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
28041   jresult = result;
28042   return jresult;
28043 }
28044
28045
28046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
28047   void * jresult ;
28048   Dali::Vector4 *result = 0 ;
28049
28050   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
28051   jresult = (void *)result;
28052   return jresult;
28053 }
28054
28055
28056 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
28057   unsigned int jresult ;
28058   bool result;
28059
28060   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
28061   jresult = result;
28062   return jresult;
28063 }
28064
28065
28066 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
28067   unsigned int jresult ;
28068   bool result;
28069
28070   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
28071   jresult = result;
28072   return jresult;
28073 }
28074
28075
28076 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
28077   unsigned int jresult ;
28078   unsigned int result;
28079
28080   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
28081   jresult = result;
28082   return jresult;
28083 }
28084
28085
28086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
28087   void * jresult ;
28088   Dali::RenderTask *result = 0 ;
28089
28090   {
28091     try {
28092       result = (Dali::RenderTask *)new Dali::RenderTask();
28093     } catch (std::out_of_range& e) {
28094       {
28095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28096       };
28097     } catch (std::exception& e) {
28098       {
28099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28100       };
28101     } catch (Dali::DaliException e) {
28102       {
28103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28104       };
28105     } catch (...) {
28106       {
28107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28108       };
28109     }
28110   }
28111
28112   jresult = (void *)result;
28113   return jresult;
28114 }
28115
28116
28117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
28118   void * jresult ;
28119   Dali::BaseHandle arg1 ;
28120   Dali::BaseHandle *argp1 ;
28121   Dali::RenderTask result;
28122
28123   argp1 = (Dali::BaseHandle *)jarg1;
28124   if (!argp1) {
28125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28126     return 0;
28127   }
28128   arg1 = *argp1;
28129   {
28130     try {
28131       result = Dali::RenderTask::DownCast(arg1);
28132     } catch (std::out_of_range& e) {
28133       {
28134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28135       };
28136     } catch (std::exception& e) {
28137       {
28138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28139       };
28140     } catch (Dali::DaliException e) {
28141       {
28142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28143       };
28144     } catch (...) {
28145       {
28146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28147       };
28148     }
28149   }
28150
28151   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28152   return jresult;
28153 }
28154
28155
28156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
28157   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28158
28159   arg1 = (Dali::RenderTask *)jarg1;
28160   {
28161     try {
28162       delete arg1;
28163     } catch (std::out_of_range& e) {
28164       {
28165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28166       };
28167     } catch (std::exception& e) {
28168       {
28169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28170       };
28171     } catch (Dali::DaliException e) {
28172       {
28173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28174       };
28175     } catch (...) {
28176       {
28177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28178       };
28179     }
28180   }
28181
28182 }
28183
28184
28185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
28186   void * jresult ;
28187   Dali::RenderTask *arg1 = 0 ;
28188   Dali::RenderTask *result = 0 ;
28189
28190   arg1 = (Dali::RenderTask *)jarg1;
28191   if (!arg1) {
28192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28193     return 0;
28194   }
28195   {
28196     try {
28197       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
28198     } catch (std::out_of_range& e) {
28199       {
28200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28201       };
28202     } catch (std::exception& e) {
28203       {
28204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28205       };
28206     } catch (Dali::DaliException e) {
28207       {
28208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28209       };
28210     } catch (...) {
28211       {
28212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28213       };
28214     }
28215   }
28216
28217   jresult = (void *)result;
28218   return jresult;
28219 }
28220
28221
28222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
28223   void * jresult ;
28224   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28225   Dali::RenderTask *arg2 = 0 ;
28226   Dali::RenderTask *result = 0 ;
28227
28228   arg1 = (Dali::RenderTask *)jarg1;
28229   arg2 = (Dali::RenderTask *)jarg2;
28230   if (!arg2) {
28231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28232     return 0;
28233   }
28234   {
28235     try {
28236       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
28237     } catch (std::out_of_range& e) {
28238       {
28239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28240       };
28241     } catch (std::exception& e) {
28242       {
28243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28244       };
28245     } catch (Dali::DaliException e) {
28246       {
28247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28248       };
28249     } catch (...) {
28250       {
28251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28252       };
28253     }
28254   }
28255
28256   jresult = (void *)result;
28257   return jresult;
28258 }
28259
28260
28261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
28262   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28263   Dali::Actor arg2 ;
28264   Dali::Actor *argp2 ;
28265
28266   arg1 = (Dali::RenderTask *)jarg1;
28267   argp2 = (Dali::Actor *)jarg2;
28268   if (!argp2) {
28269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28270     return ;
28271   }
28272   arg2 = *argp2;
28273   {
28274     try {
28275       (arg1)->SetSourceActor(arg2);
28276     } catch (std::out_of_range& e) {
28277       {
28278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28279       };
28280     } catch (std::exception& e) {
28281       {
28282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28283       };
28284     } catch (Dali::DaliException e) {
28285       {
28286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28287       };
28288     } catch (...) {
28289       {
28290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28291       };
28292     }
28293   }
28294
28295 }
28296
28297
28298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
28299   void * jresult ;
28300   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28301   Dali::Actor result;
28302
28303   arg1 = (Dali::RenderTask *)jarg1;
28304   {
28305     try {
28306       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
28307     } catch (std::out_of_range& e) {
28308       {
28309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28310       };
28311     } catch (std::exception& e) {
28312       {
28313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28314       };
28315     } catch (Dali::DaliException e) {
28316       {
28317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28318       };
28319     } catch (...) {
28320       {
28321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28322       };
28323     }
28324   }
28325
28326   jresult = new Dali::Actor((const Dali::Actor &)result);
28327   return jresult;
28328 }
28329
28330
28331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
28332   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28333   bool arg2 ;
28334
28335   arg1 = (Dali::RenderTask *)jarg1;
28336   arg2 = jarg2 ? true : false;
28337   {
28338     try {
28339       (arg1)->SetExclusive(arg2);
28340     } catch (std::out_of_range& e) {
28341       {
28342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28343       };
28344     } catch (std::exception& e) {
28345       {
28346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28347       };
28348     } catch (Dali::DaliException e) {
28349       {
28350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28351       };
28352     } catch (...) {
28353       {
28354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28355       };
28356     }
28357   }
28358
28359 }
28360
28361
28362 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
28363   unsigned int jresult ;
28364   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28365   bool result;
28366
28367   arg1 = (Dali::RenderTask *)jarg1;
28368   {
28369     try {
28370       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
28371     } catch (std::out_of_range& e) {
28372       {
28373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28374       };
28375     } catch (std::exception& e) {
28376       {
28377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28378       };
28379     } catch (Dali::DaliException e) {
28380       {
28381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28382       };
28383     } catch (...) {
28384       {
28385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28386       };
28387     }
28388   }
28389
28390   jresult = result;
28391   return jresult;
28392 }
28393
28394
28395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
28396   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28397   bool arg2 ;
28398
28399   arg1 = (Dali::RenderTask *)jarg1;
28400   arg2 = jarg2 ? true : false;
28401   {
28402     try {
28403       (arg1)->SetInputEnabled(arg2);
28404     } catch (std::out_of_range& e) {
28405       {
28406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28407       };
28408     } catch (std::exception& e) {
28409       {
28410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28411       };
28412     } catch (Dali::DaliException e) {
28413       {
28414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28415       };
28416     } catch (...) {
28417       {
28418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28419       };
28420     }
28421   }
28422
28423 }
28424
28425
28426 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
28427   unsigned int jresult ;
28428   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28429   bool result;
28430
28431   arg1 = (Dali::RenderTask *)jarg1;
28432   {
28433     try {
28434       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
28435     } catch (std::out_of_range& e) {
28436       {
28437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28438       };
28439     } catch (std::exception& e) {
28440       {
28441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28442       };
28443     } catch (Dali::DaliException e) {
28444       {
28445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28446       };
28447     } catch (...) {
28448       {
28449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28450       };
28451     }
28452   }
28453
28454   jresult = result;
28455   return jresult;
28456 }
28457
28458
28459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
28460   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28461   Dali::CameraActor arg2 ;
28462   Dali::CameraActor *argp2 ;
28463
28464   arg1 = (Dali::RenderTask *)jarg1;
28465   argp2 = (Dali::CameraActor *)jarg2;
28466   if (!argp2) {
28467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
28468     return ;
28469   }
28470   arg2 = *argp2;
28471   {
28472     try {
28473       (arg1)->SetCameraActor(arg2);
28474     } catch (std::out_of_range& e) {
28475       {
28476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28477       };
28478     } catch (std::exception& e) {
28479       {
28480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28481       };
28482     } catch (Dali::DaliException e) {
28483       {
28484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28485       };
28486     } catch (...) {
28487       {
28488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28489       };
28490     }
28491   }
28492
28493 }
28494
28495
28496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
28497   void * jresult ;
28498   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28499   Dali::CameraActor result;
28500
28501   arg1 = (Dali::RenderTask *)jarg1;
28502   {
28503     try {
28504       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
28505     } catch (std::out_of_range& e) {
28506       {
28507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28508       };
28509     } catch (std::exception& e) {
28510       {
28511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28512       };
28513     } catch (Dali::DaliException e) {
28514       {
28515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28516       };
28517     } catch (...) {
28518       {
28519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28520       };
28521     }
28522   }
28523
28524   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28525   return jresult;
28526 }
28527
28528
28529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
28530   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28531   Dali::FrameBufferImage arg2 ;
28532   Dali::FrameBufferImage *argp2 ;
28533
28534   arg1 = (Dali::RenderTask *)jarg1;
28535   argp2 = (Dali::FrameBufferImage *)jarg2;
28536   if (!argp2) {
28537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
28538     return ;
28539   }
28540   arg2 = *argp2;
28541   {
28542     try {
28543       (arg1)->SetTargetFrameBuffer(arg2);
28544     } catch (std::out_of_range& e) {
28545       {
28546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28547       };
28548     } catch (std::exception& e) {
28549       {
28550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28551       };
28552     } catch (Dali::DaliException e) {
28553       {
28554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28555       };
28556     } catch (...) {
28557       {
28558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28559       };
28560     }
28561   }
28562
28563 }
28564
28565
28566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
28567   void * jresult ;
28568   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28569   Dali::FrameBufferImage result;
28570
28571   arg1 = (Dali::RenderTask *)jarg1;
28572   {
28573     try {
28574       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
28575     } catch (std::out_of_range& e) {
28576       {
28577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28578       };
28579     } catch (std::exception& e) {
28580       {
28581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28582       };
28583     } catch (Dali::DaliException e) {
28584       {
28585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28586       };
28587     } catch (...) {
28588       {
28589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28590       };
28591     }
28592   }
28593
28594   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
28595   return jresult;
28596 }
28597
28598
28599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
28600   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28601   Dali::FrameBuffer arg2 ;
28602   Dali::FrameBuffer *argp2 ;
28603
28604   arg1 = (Dali::RenderTask *)jarg1;
28605   argp2 = (Dali::FrameBuffer *)jarg2;
28606   if (!argp2) {
28607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
28608     return ;
28609   }
28610   arg2 = *argp2;
28611   {
28612     try {
28613       (arg1)->SetFrameBuffer(arg2);
28614     } catch (std::out_of_range& e) {
28615       {
28616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28617       };
28618     } catch (std::exception& e) {
28619       {
28620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28621       };
28622     } catch (Dali::DaliException e) {
28623       {
28624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28625       };
28626     } catch (...) {
28627       {
28628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28629       };
28630     }
28631   }
28632
28633 }
28634
28635
28636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
28637   void * jresult ;
28638   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28639   Dali::FrameBuffer result;
28640
28641   arg1 = (Dali::RenderTask *)jarg1;
28642   {
28643     try {
28644       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
28645     } catch (std::out_of_range& e) {
28646       {
28647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28648       };
28649     } catch (std::exception& e) {
28650       {
28651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28652       };
28653     } catch (Dali::DaliException e) {
28654       {
28655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28656       };
28657     } catch (...) {
28658       {
28659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28660       };
28661     }
28662   }
28663
28664   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
28665   return jresult;
28666 }
28667
28668
28669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
28670   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28671   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
28672
28673   arg1 = (Dali::RenderTask *)jarg1;
28674   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
28675   {
28676     try {
28677       (arg1)->SetScreenToFrameBufferFunction(arg2);
28678     } catch (std::out_of_range& e) {
28679       {
28680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28681       };
28682     } catch (std::exception& e) {
28683       {
28684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28685       };
28686     } catch (Dali::DaliException e) {
28687       {
28688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28689       };
28690     } catch (...) {
28691       {
28692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28693       };
28694     }
28695   }
28696
28697 }
28698
28699
28700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
28701   void * jresult ;
28702   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28703   Dali::RenderTask::ScreenToFrameBufferFunction result;
28704
28705   arg1 = (Dali::RenderTask *)jarg1;
28706   {
28707     try {
28708       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
28709     } catch (std::out_of_range& e) {
28710       {
28711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28712       };
28713     } catch (std::exception& e) {
28714       {
28715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28716       };
28717     } catch (Dali::DaliException e) {
28718       {
28719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28720       };
28721     } catch (...) {
28722       {
28723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28724       };
28725     }
28726   }
28727
28728   jresult = (void *)result;
28729   return jresult;
28730 }
28731
28732
28733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
28734   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28735   Dali::Actor arg2 ;
28736   Dali::Actor *argp2 ;
28737
28738   arg1 = (Dali::RenderTask *)jarg1;
28739   argp2 = (Dali::Actor *)jarg2;
28740   if (!argp2) {
28741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28742     return ;
28743   }
28744   arg2 = *argp2;
28745   {
28746     try {
28747       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
28748     } catch (std::out_of_range& e) {
28749       {
28750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28751       };
28752     } catch (std::exception& e) {
28753       {
28754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28755       };
28756     } catch (Dali::DaliException e) {
28757       {
28758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28759       };
28760     } catch (...) {
28761       {
28762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28763       };
28764     }
28765   }
28766
28767 }
28768
28769
28770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
28771   void * jresult ;
28772   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28773   Dali::Actor result;
28774
28775   arg1 = (Dali::RenderTask *)jarg1;
28776   {
28777     try {
28778       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
28779     } catch (std::out_of_range& e) {
28780       {
28781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28782       };
28783     } catch (std::exception& e) {
28784       {
28785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28786       };
28787     } catch (Dali::DaliException e) {
28788       {
28789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28790       };
28791     } catch (...) {
28792       {
28793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28794       };
28795     }
28796   }
28797
28798   jresult = new Dali::Actor((const Dali::Actor &)result);
28799   return jresult;
28800 }
28801
28802
28803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
28804   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28805   Dali::Vector2 arg2 ;
28806   Dali::Vector2 *argp2 ;
28807
28808   arg1 = (Dali::RenderTask *)jarg1;
28809   argp2 = (Dali::Vector2 *)jarg2;
28810   if (!argp2) {
28811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28812     return ;
28813   }
28814   arg2 = *argp2;
28815   {
28816     try {
28817       (arg1)->SetViewportPosition(arg2);
28818     } catch (std::out_of_range& e) {
28819       {
28820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28821       };
28822     } catch (std::exception& e) {
28823       {
28824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28825       };
28826     } catch (Dali::DaliException e) {
28827       {
28828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28829       };
28830     } catch (...) {
28831       {
28832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28833       };
28834     }
28835   }
28836
28837 }
28838
28839
28840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
28841   void * jresult ;
28842   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28843   Dali::Vector2 result;
28844
28845   arg1 = (Dali::RenderTask *)jarg1;
28846   {
28847     try {
28848       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
28849     } catch (std::out_of_range& e) {
28850       {
28851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28852       };
28853     } catch (std::exception& e) {
28854       {
28855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28856       };
28857     } catch (Dali::DaliException e) {
28858       {
28859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28860       };
28861     } catch (...) {
28862       {
28863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28864       };
28865     }
28866   }
28867
28868   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28869   return jresult;
28870 }
28871
28872
28873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
28874   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28875   Dali::Vector2 arg2 ;
28876   Dali::Vector2 *argp2 ;
28877
28878   arg1 = (Dali::RenderTask *)jarg1;
28879   argp2 = (Dali::Vector2 *)jarg2;
28880   if (!argp2) {
28881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28882     return ;
28883   }
28884   arg2 = *argp2;
28885   {
28886     try {
28887       (arg1)->SetViewportSize(arg2);
28888     } catch (std::out_of_range& e) {
28889       {
28890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28891       };
28892     } catch (std::exception& e) {
28893       {
28894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28895       };
28896     } catch (Dali::DaliException e) {
28897       {
28898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28899       };
28900     } catch (...) {
28901       {
28902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28903       };
28904     }
28905   }
28906
28907 }
28908
28909
28910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
28911   void * jresult ;
28912   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28913   Dali::Vector2 result;
28914
28915   arg1 = (Dali::RenderTask *)jarg1;
28916   {
28917     try {
28918       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
28919     } catch (std::out_of_range& e) {
28920       {
28921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28922       };
28923     } catch (std::exception& e) {
28924       {
28925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28926       };
28927     } catch (Dali::DaliException e) {
28928       {
28929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28930       };
28931     } catch (...) {
28932       {
28933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28934       };
28935     }
28936   }
28937
28938   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28939   return jresult;
28940 }
28941
28942
28943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
28944   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28945   Dali::Viewport arg2 ;
28946   Dali::Viewport *argp2 ;
28947
28948   arg1 = (Dali::RenderTask *)jarg1;
28949   argp2 = (Dali::Viewport *)jarg2;
28950   if (!argp2) {
28951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
28952     return ;
28953   }
28954   arg2 = *argp2;
28955   {
28956     try {
28957       (arg1)->SetViewport(arg2);
28958     } catch (std::out_of_range& e) {
28959       {
28960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28961       };
28962     } catch (std::exception& e) {
28963       {
28964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28965       };
28966     } catch (Dali::DaliException e) {
28967       {
28968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28969       };
28970     } catch (...) {
28971       {
28972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28973       };
28974     }
28975   }
28976
28977 }
28978
28979
28980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
28981   void * jresult ;
28982   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28983   Dali::Viewport result;
28984
28985   arg1 = (Dali::RenderTask *)jarg1;
28986   {
28987     try {
28988       result = ((Dali::RenderTask const *)arg1)->GetViewport();
28989     } catch (std::out_of_range& e) {
28990       {
28991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28992       };
28993     } catch (std::exception& e) {
28994       {
28995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28996       };
28997     } catch (Dali::DaliException e) {
28998       {
28999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29000       };
29001     } catch (...) {
29002       {
29003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29004       };
29005     }
29006   }
29007
29008   jresult = new Dali::Viewport((const Dali::Viewport &)result);
29009   return jresult;
29010 }
29011
29012
29013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
29014   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29015   Dali::Vector4 *arg2 = 0 ;
29016
29017   arg1 = (Dali::RenderTask *)jarg1;
29018   arg2 = (Dali::Vector4 *)jarg2;
29019   if (!arg2) {
29020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
29021     return ;
29022   }
29023   {
29024     try {
29025       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
29026     } catch (std::out_of_range& e) {
29027       {
29028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29029       };
29030     } catch (std::exception& e) {
29031       {
29032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29033       };
29034     } catch (Dali::DaliException e) {
29035       {
29036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29037       };
29038     } catch (...) {
29039       {
29040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29041       };
29042     }
29043   }
29044
29045 }
29046
29047
29048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
29049   void * jresult ;
29050   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29051   Dali::Vector4 result;
29052
29053   arg1 = (Dali::RenderTask *)jarg1;
29054   {
29055     try {
29056       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
29057     } catch (std::out_of_range& e) {
29058       {
29059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29060       };
29061     } catch (std::exception& e) {
29062       {
29063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29064       };
29065     } catch (Dali::DaliException e) {
29066       {
29067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29068       };
29069     } catch (...) {
29070       {
29071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29072       };
29073     }
29074   }
29075
29076   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
29077   return jresult;
29078 }
29079
29080
29081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
29082   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29083   bool arg2 ;
29084
29085   arg1 = (Dali::RenderTask *)jarg1;
29086   arg2 = jarg2 ? true : false;
29087   {
29088     try {
29089       (arg1)->SetClearEnabled(arg2);
29090     } catch (std::out_of_range& e) {
29091       {
29092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29093       };
29094     } catch (std::exception& e) {
29095       {
29096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29097       };
29098     } catch (Dali::DaliException e) {
29099       {
29100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29101       };
29102     } catch (...) {
29103       {
29104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29105       };
29106     }
29107   }
29108
29109 }
29110
29111
29112 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
29113   unsigned int jresult ;
29114   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29115   bool result;
29116
29117   arg1 = (Dali::RenderTask *)jarg1;
29118   {
29119     try {
29120       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
29121     } catch (std::out_of_range& e) {
29122       {
29123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29124       };
29125     } catch (std::exception& e) {
29126       {
29127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29128       };
29129     } catch (Dali::DaliException e) {
29130       {
29131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29132       };
29133     } catch (...) {
29134       {
29135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29136       };
29137     }
29138   }
29139
29140   jresult = result;
29141   return jresult;
29142 }
29143
29144
29145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
29146   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29147   bool arg2 ;
29148
29149   arg1 = (Dali::RenderTask *)jarg1;
29150   arg2 = jarg2 ? true : false;
29151   {
29152     try {
29153       (arg1)->SetCullMode(arg2);
29154     } catch (std::out_of_range& e) {
29155       {
29156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29157       };
29158     } catch (std::exception& e) {
29159       {
29160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29161       };
29162     } catch (Dali::DaliException e) {
29163       {
29164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29165       };
29166     } catch (...) {
29167       {
29168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29169       };
29170     }
29171   }
29172
29173 }
29174
29175
29176 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
29177   unsigned int jresult ;
29178   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29179   bool result;
29180
29181   arg1 = (Dali::RenderTask *)jarg1;
29182   {
29183     try {
29184       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
29185     } catch (std::out_of_range& e) {
29186       {
29187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29188       };
29189     } catch (std::exception& e) {
29190       {
29191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29192       };
29193     } catch (Dali::DaliException e) {
29194       {
29195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29196       };
29197     } catch (...) {
29198       {
29199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29200       };
29201     }
29202   }
29203
29204   jresult = result;
29205   return jresult;
29206 }
29207
29208
29209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
29210   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29211   unsigned int arg2 ;
29212
29213   arg1 = (Dali::RenderTask *)jarg1;
29214   arg2 = (unsigned int)jarg2;
29215   {
29216     try {
29217       (arg1)->SetRefreshRate(arg2);
29218     } catch (std::out_of_range& e) {
29219       {
29220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29221       };
29222     } catch (std::exception& e) {
29223       {
29224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29225       };
29226     } catch (Dali::DaliException e) {
29227       {
29228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29229       };
29230     } catch (...) {
29231       {
29232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29233       };
29234     }
29235   }
29236
29237 }
29238
29239
29240 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
29241   unsigned int jresult ;
29242   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29243   unsigned int result;
29244
29245   arg1 = (Dali::RenderTask *)jarg1;
29246   {
29247     try {
29248       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
29249     } catch (std::out_of_range& e) {
29250       {
29251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29252       };
29253     } catch (std::exception& e) {
29254       {
29255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29256       };
29257     } catch (Dali::DaliException e) {
29258       {
29259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29260       };
29261     } catch (...) {
29262       {
29263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29264       };
29265     }
29266   }
29267
29268   jresult = result;
29269   return jresult;
29270 }
29271
29272
29273 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
29274   unsigned int jresult ;
29275   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29276   Dali::Vector3 *arg2 = 0 ;
29277   float *arg3 = 0 ;
29278   float *arg4 = 0 ;
29279   bool result;
29280
29281   arg1 = (Dali::RenderTask *)jarg1;
29282   arg2 = (Dali::Vector3 *)jarg2;
29283   if (!arg2) {
29284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29285     return 0;
29286   }
29287   arg3 = (float *)jarg3;
29288   arg4 = (float *)jarg4;
29289   {
29290     try {
29291       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
29292     } catch (std::out_of_range& e) {
29293       {
29294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29295       };
29296     } catch (std::exception& e) {
29297       {
29298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29299       };
29300     } catch (Dali::DaliException e) {
29301       {
29302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29303       };
29304     } catch (...) {
29305       {
29306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29307       };
29308     }
29309   }
29310
29311   jresult = result;
29312   return jresult;
29313 }
29314
29315
29316 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
29317   unsigned int jresult ;
29318   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29319   Dali::Actor arg2 ;
29320   float arg3 ;
29321   float arg4 ;
29322   float *arg5 = 0 ;
29323   float *arg6 = 0 ;
29324   Dali::Actor *argp2 ;
29325   bool result;
29326
29327   arg1 = (Dali::RenderTask *)jarg1;
29328   argp2 = (Dali::Actor *)jarg2;
29329   if (!argp2) {
29330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29331     return 0;
29332   }
29333   arg2 = *argp2;
29334   arg3 = (float)jarg3;
29335   arg4 = (float)jarg4;
29336   arg5 = (float *)jarg5;
29337   arg6 = (float *)jarg6;
29338   {
29339     try {
29340       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
29341     } catch (std::out_of_range& e) {
29342       {
29343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29344       };
29345     } catch (std::exception& e) {
29346       {
29347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29348       };
29349     } catch (Dali::DaliException e) {
29350       {
29351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29352       };
29353     } catch (...) {
29354       {
29355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29356       };
29357     }
29358   }
29359
29360   jresult = result;
29361   return jresult;
29362 }
29363
29364
29365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
29366   void * jresult ;
29367   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29368   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
29369
29370   arg1 = (Dali::RenderTask *)jarg1;
29371   {
29372     try {
29373       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
29374     } catch (std::out_of_range& e) {
29375       {
29376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29377       };
29378     } catch (std::exception& e) {
29379       {
29380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29381       };
29382     } catch (Dali::DaliException e) {
29383       {
29384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29385       };
29386     } catch (...) {
29387       {
29388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29389       };
29390     }
29391   }
29392
29393   jresult = (void *)result;
29394   return jresult;
29395 }
29396
29397
29398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
29399   void * jresult ;
29400   int arg1 ;
29401   Dali::TouchPoint::State arg2 ;
29402   float arg3 ;
29403   float arg4 ;
29404   Dali::TouchPoint *result = 0 ;
29405
29406   arg1 = (int)jarg1;
29407   arg2 = (Dali::TouchPoint::State)jarg2;
29408   arg3 = (float)jarg3;
29409   arg4 = (float)jarg4;
29410   {
29411     try {
29412       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
29413     } catch (std::out_of_range& e) {
29414       {
29415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29416       };
29417     } catch (std::exception& e) {
29418       {
29419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29420       };
29421     } catch (Dali::DaliException e) {
29422       {
29423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29424       };
29425     } catch (...) {
29426       {
29427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29428       };
29429     }
29430   }
29431
29432   jresult = (void *)result;
29433   return jresult;
29434 }
29435
29436
29437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
29438   void * jresult ;
29439   int arg1 ;
29440   Dali::TouchPoint::State arg2 ;
29441   float arg3 ;
29442   float arg4 ;
29443   float arg5 ;
29444   float arg6 ;
29445   Dali::TouchPoint *result = 0 ;
29446
29447   arg1 = (int)jarg1;
29448   arg2 = (Dali::TouchPoint::State)jarg2;
29449   arg3 = (float)jarg3;
29450   arg4 = (float)jarg4;
29451   arg5 = (float)jarg5;
29452   arg6 = (float)jarg6;
29453   {
29454     try {
29455       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
29456     } catch (std::out_of_range& e) {
29457       {
29458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29459       };
29460     } catch (std::exception& e) {
29461       {
29462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29463       };
29464     } catch (Dali::DaliException e) {
29465       {
29466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29467       };
29468     } catch (...) {
29469       {
29470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29471       };
29472     }
29473   }
29474
29475   jresult = (void *)result;
29476   return jresult;
29477 }
29478
29479
29480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
29481   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29482
29483   arg1 = (Dali::TouchPoint *)jarg1;
29484   {
29485     try {
29486       delete arg1;
29487     } catch (std::out_of_range& e) {
29488       {
29489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29490       };
29491     } catch (std::exception& e) {
29492       {
29493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29494       };
29495     } catch (Dali::DaliException e) {
29496       {
29497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29498       };
29499     } catch (...) {
29500       {
29501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29502       };
29503     }
29504   }
29505
29506 }
29507
29508
29509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
29510   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29511   int arg2 ;
29512
29513   arg1 = (Dali::TouchPoint *)jarg1;
29514   arg2 = (int)jarg2;
29515   if (arg1) (arg1)->deviceId = arg2;
29516 }
29517
29518
29519 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
29520   int jresult ;
29521   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29522   int result;
29523
29524   arg1 = (Dali::TouchPoint *)jarg1;
29525   result = (int) ((arg1)->deviceId);
29526   jresult = result;
29527   return jresult;
29528 }
29529
29530
29531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
29532   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29533   Dali::TouchPoint::State arg2 ;
29534
29535   arg1 = (Dali::TouchPoint *)jarg1;
29536   arg2 = (Dali::TouchPoint::State)jarg2;
29537   if (arg1) (arg1)->state = arg2;
29538 }
29539
29540
29541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
29542   int jresult ;
29543   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29544   Dali::TouchPoint::State result;
29545
29546   arg1 = (Dali::TouchPoint *)jarg1;
29547   result = (Dali::TouchPoint::State) ((arg1)->state);
29548   jresult = (int)result;
29549   return jresult;
29550 }
29551
29552
29553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
29554   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29555   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
29556
29557   arg1 = (Dali::TouchPoint *)jarg1;
29558   arg2 = (Dali::Actor *)jarg2;
29559   if (arg1) (arg1)->hitActor = *arg2;
29560 }
29561
29562
29563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
29564   void * jresult ;
29565   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29566   Dali::Actor *result = 0 ;
29567
29568   arg1 = (Dali::TouchPoint *)jarg1;
29569   result = (Dali::Actor *)& ((arg1)->hitActor);
29570   jresult = (void *)result;
29571   return jresult;
29572 }
29573
29574
29575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
29576   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29577   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29578
29579   arg1 = (Dali::TouchPoint *)jarg1;
29580   arg2 = (Dali::Vector2 *)jarg2;
29581   if (arg1) (arg1)->local = *arg2;
29582 }
29583
29584
29585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
29586   void * jresult ;
29587   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29588   Dali::Vector2 *result = 0 ;
29589
29590   arg1 = (Dali::TouchPoint *)jarg1;
29591   result = (Dali::Vector2 *)& ((arg1)->local);
29592   jresult = (void *)result;
29593   return jresult;
29594 }
29595
29596
29597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
29598   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29599   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29600
29601   arg1 = (Dali::TouchPoint *)jarg1;
29602   arg2 = (Dali::Vector2 *)jarg2;
29603   if (arg1) (arg1)->screen = *arg2;
29604 }
29605
29606
29607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
29608   void * jresult ;
29609   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29610   Dali::Vector2 *result = 0 ;
29611
29612   arg1 = (Dali::TouchPoint *)jarg1;
29613   result = (Dali::Vector2 *)& ((arg1)->screen);
29614   jresult = (void *)result;
29615   return jresult;
29616 }
29617
29618
29619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
29620   void * jresult ;
29621   Dali::TouchData *result = 0 ;
29622
29623   {
29624     try {
29625       result = (Dali::TouchData *)new Dali::TouchData();
29626     } catch (std::out_of_range& e) {
29627       {
29628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29629       };
29630     } catch (std::exception& e) {
29631       {
29632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29633       };
29634     } catch (Dali::DaliException e) {
29635       {
29636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29637       };
29638     } catch (...) {
29639       {
29640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29641       };
29642     }
29643   }
29644
29645   jresult = (void *)result;
29646   return jresult;
29647 }
29648
29649
29650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
29651   void * jresult ;
29652   Dali::TouchData *arg1 = 0 ;
29653   Dali::TouchData *result = 0 ;
29654
29655   arg1 = (Dali::TouchData *)jarg1;
29656   if (!arg1) {
29657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29658     return 0;
29659   }
29660   {
29661     try {
29662       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
29663     } catch (std::out_of_range& e) {
29664       {
29665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29666       };
29667     } catch (std::exception& e) {
29668       {
29669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29670       };
29671     } catch (Dali::DaliException e) {
29672       {
29673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29674       };
29675     } catch (...) {
29676       {
29677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29678       };
29679     }
29680   }
29681
29682   jresult = (void *)result;
29683   return jresult;
29684 }
29685
29686
29687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
29688   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29689
29690   arg1 = (Dali::TouchData *)jarg1;
29691   {
29692     try {
29693       delete arg1;
29694     } catch (std::out_of_range& e) {
29695       {
29696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29697       };
29698     } catch (std::exception& e) {
29699       {
29700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29701       };
29702     } catch (Dali::DaliException e) {
29703       {
29704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29705       };
29706     } catch (...) {
29707       {
29708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29709       };
29710     }
29711   }
29712
29713 }
29714
29715
29716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
29717   void * jresult ;
29718   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29719   Dali::TouchData *arg2 = 0 ;
29720   Dali::TouchData *result = 0 ;
29721
29722   arg1 = (Dali::TouchData *)jarg1;
29723   arg2 = (Dali::TouchData *)jarg2;
29724   if (!arg2) {
29725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29726     return 0;
29727   }
29728   {
29729     try {
29730       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
29731     } catch (std::out_of_range& e) {
29732       {
29733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29734       };
29735     } catch (std::exception& e) {
29736       {
29737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29738       };
29739     } catch (Dali::DaliException e) {
29740       {
29741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29742       };
29743     } catch (...) {
29744       {
29745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29746       };
29747     }
29748   }
29749
29750   jresult = (void *)result;
29751   return jresult;
29752 }
29753
29754
29755 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
29756   unsigned long jresult ;
29757   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29758   unsigned long result;
29759
29760   arg1 = (Dali::TouchData *)jarg1;
29761   {
29762     try {
29763       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
29764     } catch (std::out_of_range& e) {
29765       {
29766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29767       };
29768     } catch (std::exception& e) {
29769       {
29770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29771       };
29772     } catch (Dali::DaliException e) {
29773       {
29774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29775       };
29776     } catch (...) {
29777       {
29778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29779       };
29780     }
29781   }
29782
29783   jresult = (unsigned long)result;
29784   return jresult;
29785 }
29786
29787
29788 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
29789   unsigned long jresult ;
29790   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29791   std::size_t result;
29792
29793   arg1 = (Dali::TouchData *)jarg1;
29794   {
29795     try {
29796       result = ((Dali::TouchData const *)arg1)->GetPointCount();
29797     } catch (std::out_of_range& e) {
29798       {
29799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29800       };
29801     } catch (std::exception& e) {
29802       {
29803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29804       };
29805     } catch (Dali::DaliException e) {
29806       {
29807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29808       };
29809     } catch (...) {
29810       {
29811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29812       };
29813     }
29814   }
29815
29816   jresult = (unsigned long)result;
29817   return jresult;
29818 }
29819
29820
29821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
29822   int jresult ;
29823   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29824   std::size_t arg2 ;
29825   int32_t result;
29826
29827   arg1 = (Dali::TouchData *)jarg1;
29828   arg2 = (std::size_t)jarg2;
29829   {
29830     try {
29831       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
29832     } catch (std::out_of_range& e) {
29833       {
29834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29835       };
29836     } catch (std::exception& e) {
29837       {
29838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29839       };
29840     } catch (Dali::DaliException e) {
29841       {
29842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29843       };
29844     } catch (...) {
29845       {
29846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29847       };
29848     }
29849   }
29850
29851   jresult = result;
29852   return jresult;
29853 }
29854
29855
29856 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
29857   int jresult ;
29858   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29859   std::size_t arg2 ;
29860   Dali::PointState::Type result;
29861
29862   arg1 = (Dali::TouchData *)jarg1;
29863   arg2 = (std::size_t)jarg2;
29864   {
29865     try {
29866       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
29867     } catch (std::out_of_range& e) {
29868       {
29869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29870       };
29871     } catch (std::exception& e) {
29872       {
29873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29874       };
29875     } catch (Dali::DaliException e) {
29876       {
29877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29878       };
29879     } catch (...) {
29880       {
29881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29882       };
29883     }
29884   }
29885
29886   jresult = (int)result;
29887   return jresult;
29888 }
29889
29890
29891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
29892   void * jresult ;
29893   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29894   std::size_t arg2 ;
29895   Dali::Actor result;
29896
29897   arg1 = (Dali::TouchData *)jarg1;
29898   arg2 = (std::size_t)jarg2;
29899   {
29900     try {
29901       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
29902     } catch (std::out_of_range& e) {
29903       {
29904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29905       };
29906     } catch (std::exception& e) {
29907       {
29908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29909       };
29910     } catch (Dali::DaliException e) {
29911       {
29912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29913       };
29914     } catch (...) {
29915       {
29916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29917       };
29918     }
29919   }
29920
29921   jresult = new Dali::Actor((const Dali::Actor &)result);
29922   return jresult;
29923 }
29924
29925
29926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
29927   void * jresult ;
29928   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29929   std::size_t arg2 ;
29930   Dali::Vector2 *result = 0 ;
29931
29932   arg1 = (Dali::TouchData *)jarg1;
29933   arg2 = (std::size_t)jarg2;
29934   {
29935     try {
29936       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
29937     } catch (std::out_of_range& e) {
29938       {
29939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29940       };
29941     } catch (std::exception& e) {
29942       {
29943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29944       };
29945     } catch (Dali::DaliException e) {
29946       {
29947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29948       };
29949     } catch (...) {
29950       {
29951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29952       };
29953     }
29954   }
29955
29956   jresult = (void *)result;
29957   return jresult;
29958 }
29959
29960
29961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
29962   void * jresult ;
29963   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29964   std::size_t arg2 ;
29965   Dali::Vector2 *result = 0 ;
29966
29967   arg1 = (Dali::TouchData *)jarg1;
29968   arg2 = (std::size_t)jarg2;
29969   {
29970     try {
29971       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
29972     } catch (std::out_of_range& e) {
29973       {
29974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29975       };
29976     } catch (std::exception& e) {
29977       {
29978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29979       };
29980     } catch (Dali::DaliException e) {
29981       {
29982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29983       };
29984     } catch (...) {
29985       {
29986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29987       };
29988     }
29989   }
29990
29991   jresult = (void *)result;
29992   return jresult;
29993 }
29994
29995
29996 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
29997   float jresult ;
29998   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29999   std::size_t arg2 ;
30000   float result;
30001
30002   arg1 = (Dali::TouchData *)jarg1;
30003   arg2 = (std::size_t)jarg2;
30004   {
30005     try {
30006       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
30007     } catch (std::out_of_range& e) {
30008       {
30009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30010       };
30011     } catch (std::exception& e) {
30012       {
30013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30014       };
30015     } catch (Dali::DaliException e) {
30016       {
30017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30018       };
30019     } catch (...) {
30020       {
30021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30022       };
30023     }
30024   }
30025
30026   jresult = result;
30027   return jresult;
30028 }
30029
30030
30031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
30032   void * jresult ;
30033   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30034   std::size_t arg2 ;
30035   Dali::Vector2 *result = 0 ;
30036
30037   arg1 = (Dali::TouchData *)jarg1;
30038   arg2 = (std::size_t)jarg2;
30039   {
30040     try {
30041       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
30042     } catch (std::out_of_range& e) {
30043       {
30044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30045       };
30046     } catch (std::exception& e) {
30047       {
30048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30049       };
30050     } catch (Dali::DaliException e) {
30051       {
30052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30053       };
30054     } catch (...) {
30055       {
30056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30057       };
30058     }
30059   }
30060
30061   jresult = (void *)result;
30062   return jresult;
30063 }
30064
30065
30066 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
30067   float jresult ;
30068   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30069   std::size_t arg2 ;
30070   float result;
30071
30072   arg1 = (Dali::TouchData *)jarg1;
30073   arg2 = (std::size_t)jarg2;
30074   {
30075     try {
30076       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
30077     } catch (std::out_of_range& e) {
30078       {
30079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30080       };
30081     } catch (std::exception& e) {
30082       {
30083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30084       };
30085     } catch (Dali::DaliException e) {
30086       {
30087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30088       };
30089     } catch (...) {
30090       {
30091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30092       };
30093     }
30094   }
30095
30096   jresult = result;
30097   return jresult;
30098 }
30099
30100
30101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
30102   void * jresult ;
30103   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30104   std::size_t arg2 ;
30105   Dali::Degree result;
30106
30107   arg1 = (Dali::TouchData *)jarg1;
30108   arg2 = (std::size_t)jarg2;
30109   {
30110     try {
30111       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
30112     } catch (std::out_of_range& e) {
30113       {
30114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30115       };
30116     } catch (std::exception& e) {
30117       {
30118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30119       };
30120     } catch (Dali::DaliException e) {
30121       {
30122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30123       };
30124     } catch (...) {
30125       {
30126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30127       };
30128     }
30129   }
30130
30131   jresult = new Dali::Degree((const Dali::Degree &)result);
30132   return jresult;
30133 }
30134
30135
30136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
30137   void * jresult ;
30138   Dali::GestureDetector *result = 0 ;
30139
30140   {
30141     try {
30142       result = (Dali::GestureDetector *)new Dali::GestureDetector();
30143     } catch (std::out_of_range& e) {
30144       {
30145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30146       };
30147     } catch (std::exception& e) {
30148       {
30149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30150       };
30151     } catch (Dali::DaliException e) {
30152       {
30153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30154       };
30155     } catch (...) {
30156       {
30157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30158       };
30159     }
30160   }
30161
30162   jresult = (void *)result;
30163   return jresult;
30164 }
30165
30166
30167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
30168   void * jresult ;
30169   Dali::BaseHandle arg1 ;
30170   Dali::BaseHandle *argp1 ;
30171   Dali::GestureDetector result;
30172
30173   argp1 = (Dali::BaseHandle *)jarg1;
30174   if (!argp1) {
30175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30176     return 0;
30177   }
30178   arg1 = *argp1;
30179   {
30180     try {
30181       result = Dali::GestureDetector::DownCast(arg1);
30182     } catch (std::out_of_range& e) {
30183       {
30184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30185       };
30186     } catch (std::exception& e) {
30187       {
30188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30189       };
30190     } catch (Dali::DaliException e) {
30191       {
30192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30193       };
30194     } catch (...) {
30195       {
30196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30197       };
30198     }
30199   }
30200
30201   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
30202   return jresult;
30203 }
30204
30205
30206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
30207   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30208
30209   arg1 = (Dali::GestureDetector *)jarg1;
30210   {
30211     try {
30212       delete arg1;
30213     } catch (std::out_of_range& e) {
30214       {
30215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30216       };
30217     } catch (std::exception& e) {
30218       {
30219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30220       };
30221     } catch (Dali::DaliException e) {
30222       {
30223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30224       };
30225     } catch (...) {
30226       {
30227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30228       };
30229     }
30230   }
30231
30232 }
30233
30234
30235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
30236   void * jresult ;
30237   Dali::GestureDetector *arg1 = 0 ;
30238   Dali::GestureDetector *result = 0 ;
30239
30240   arg1 = (Dali::GestureDetector *)jarg1;
30241   if (!arg1) {
30242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30243     return 0;
30244   }
30245   {
30246     try {
30247       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
30248     } catch (std::out_of_range& e) {
30249       {
30250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30251       };
30252     } catch (std::exception& e) {
30253       {
30254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30255       };
30256     } catch (Dali::DaliException e) {
30257       {
30258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30259       };
30260     } catch (...) {
30261       {
30262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30263       };
30264     }
30265   }
30266
30267   jresult = (void *)result;
30268   return jresult;
30269 }
30270
30271
30272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
30273   void * jresult ;
30274   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30275   Dali::GestureDetector *arg2 = 0 ;
30276   Dali::GestureDetector *result = 0 ;
30277
30278   arg1 = (Dali::GestureDetector *)jarg1;
30279   arg2 = (Dali::GestureDetector *)jarg2;
30280   if (!arg2) {
30281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30282     return 0;
30283   }
30284   {
30285     try {
30286       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
30287     } catch (std::out_of_range& e) {
30288       {
30289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30290       };
30291     } catch (std::exception& e) {
30292       {
30293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30294       };
30295     } catch (Dali::DaliException e) {
30296       {
30297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30298       };
30299     } catch (...) {
30300       {
30301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30302       };
30303     }
30304   }
30305
30306   jresult = (void *)result;
30307   return jresult;
30308 }
30309
30310
30311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
30312   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30313   Dali::Actor arg2 ;
30314   Dali::Actor *argp2 ;
30315
30316   arg1 = (Dali::GestureDetector *)jarg1;
30317   argp2 = (Dali::Actor *)jarg2;
30318   if (!argp2) {
30319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30320     return ;
30321   }
30322   arg2 = *argp2;
30323   {
30324     try {
30325       (arg1)->Attach(arg2);
30326     } catch (std::out_of_range& e) {
30327       {
30328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30329       };
30330     } catch (std::exception& e) {
30331       {
30332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30333       };
30334     } catch (Dali::DaliException e) {
30335       {
30336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30337       };
30338     } catch (...) {
30339       {
30340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30341       };
30342     }
30343   }
30344
30345 }
30346
30347
30348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
30349   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30350   Dali::Actor arg2 ;
30351   Dali::Actor *argp2 ;
30352
30353   arg1 = (Dali::GestureDetector *)jarg1;
30354   argp2 = (Dali::Actor *)jarg2;
30355   if (!argp2) {
30356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30357     return ;
30358   }
30359   arg2 = *argp2;
30360   {
30361     try {
30362       (arg1)->Detach(arg2);
30363     } catch (std::out_of_range& e) {
30364       {
30365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30366       };
30367     } catch (std::exception& e) {
30368       {
30369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30370       };
30371     } catch (Dali::DaliException e) {
30372       {
30373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30374       };
30375     } catch (...) {
30376       {
30377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30378       };
30379     }
30380   }
30381
30382 }
30383
30384
30385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
30386   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30387
30388   arg1 = (Dali::GestureDetector *)jarg1;
30389   {
30390     try {
30391       (arg1)->DetachAll();
30392     } catch (std::out_of_range& e) {
30393       {
30394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30395       };
30396     } catch (std::exception& e) {
30397       {
30398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30399       };
30400     } catch (Dali::DaliException e) {
30401       {
30402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30403       };
30404     } catch (...) {
30405       {
30406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30407       };
30408     }
30409   }
30410
30411 }
30412
30413
30414 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
30415   unsigned long jresult ;
30416   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30417   size_t result;
30418
30419   arg1 = (Dali::GestureDetector *)jarg1;
30420   {
30421     try {
30422       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
30423     } catch (std::out_of_range& e) {
30424       {
30425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30426       };
30427     } catch (std::exception& e) {
30428       {
30429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30430       };
30431     } catch (Dali::DaliException e) {
30432       {
30433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30434       };
30435     } catch (...) {
30436       {
30437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30438       };
30439     }
30440   }
30441
30442   jresult = (unsigned long)result;
30443   return jresult;
30444 }
30445
30446
30447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
30448   void * jresult ;
30449   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30450   size_t arg2 ;
30451   Dali::Actor result;
30452
30453   arg1 = (Dali::GestureDetector *)jarg1;
30454   arg2 = (size_t)jarg2;
30455   {
30456     try {
30457       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
30458     } catch (std::out_of_range& e) {
30459       {
30460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30461       };
30462     } catch (std::exception& e) {
30463       {
30464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30465       };
30466     } catch (Dali::DaliException e) {
30467       {
30468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30469       };
30470     } catch (...) {
30471       {
30472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30473       };
30474     }
30475   }
30476
30477   jresult = new Dali::Actor((const Dali::Actor &)result);
30478   return jresult;
30479 }
30480
30481
30482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
30483   void * jresult ;
30484   Dali::Gesture *arg1 = 0 ;
30485   Dali::Gesture *result = 0 ;
30486
30487   arg1 = (Dali::Gesture *)jarg1;
30488   if (!arg1) {
30489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30490     return 0;
30491   }
30492   {
30493     try {
30494       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
30495     } catch (std::out_of_range& e) {
30496       {
30497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30498       };
30499     } catch (std::exception& e) {
30500       {
30501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30502       };
30503     } catch (Dali::DaliException e) {
30504       {
30505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30506       };
30507     } catch (...) {
30508       {
30509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30510       };
30511     }
30512   }
30513
30514   jresult = (void *)result;
30515   return jresult;
30516 }
30517
30518
30519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
30520   void * jresult ;
30521   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30522   Dali::Gesture *arg2 = 0 ;
30523   Dali::Gesture *result = 0 ;
30524
30525   arg1 = (Dali::Gesture *)jarg1;
30526   arg2 = (Dali::Gesture *)jarg2;
30527   if (!arg2) {
30528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30529     return 0;
30530   }
30531   {
30532     try {
30533       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
30534     } catch (std::out_of_range& e) {
30535       {
30536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30537       };
30538     } catch (std::exception& e) {
30539       {
30540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30541       };
30542     } catch (Dali::DaliException e) {
30543       {
30544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30545       };
30546     } catch (...) {
30547       {
30548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30549       };
30550     }
30551   }
30552
30553   jresult = (void *)result;
30554   return jresult;
30555 }
30556
30557
30558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
30559   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30560
30561   arg1 = (Dali::Gesture *)jarg1;
30562   {
30563     try {
30564       delete arg1;
30565     } catch (std::out_of_range& e) {
30566       {
30567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30568       };
30569     } catch (std::exception& e) {
30570       {
30571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30572       };
30573     } catch (Dali::DaliException e) {
30574       {
30575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30576       };
30577     } catch (...) {
30578       {
30579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30580       };
30581     }
30582   }
30583
30584 }
30585
30586
30587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
30588   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30589   Dali::Gesture::Type arg2 ;
30590
30591   arg1 = (Dali::Gesture *)jarg1;
30592   arg2 = (Dali::Gesture::Type)jarg2;
30593   if (arg1) (arg1)->type = arg2;
30594 }
30595
30596
30597 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
30598   int jresult ;
30599   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30600   Dali::Gesture::Type result;
30601
30602   arg1 = (Dali::Gesture *)jarg1;
30603   result = (Dali::Gesture::Type) ((arg1)->type);
30604   jresult = (int)result;
30605   return jresult;
30606 }
30607
30608
30609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
30610   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30611   Dali::Gesture::State arg2 ;
30612
30613   arg1 = (Dali::Gesture *)jarg1;
30614   arg2 = (Dali::Gesture::State)jarg2;
30615   if (arg1) (arg1)->state = arg2;
30616 }
30617
30618
30619 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
30620   int jresult ;
30621   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30622   Dali::Gesture::State result;
30623
30624   arg1 = (Dali::Gesture *)jarg1;
30625   result = (Dali::Gesture::State) ((arg1)->state);
30626   jresult = (int)result;
30627   return jresult;
30628 }
30629
30630
30631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
30632   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30633   unsigned int arg2 ;
30634
30635   arg1 = (Dali::Gesture *)jarg1;
30636   arg2 = (unsigned int)jarg2;
30637   if (arg1) (arg1)->time = arg2;
30638 }
30639
30640
30641 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
30642   unsigned int jresult ;
30643   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30644   unsigned int result;
30645
30646   arg1 = (Dali::Gesture *)jarg1;
30647   result = (unsigned int) ((arg1)->time);
30648   jresult = result;
30649   return jresult;
30650 }
30651
30652
30653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
30654   void * jresult ;
30655   Dali::HoverEvent *result = 0 ;
30656
30657   {
30658     try {
30659       result = (Dali::HoverEvent *)new Dali::HoverEvent();
30660     } catch (std::out_of_range& e) {
30661       {
30662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30663       };
30664     } catch (std::exception& e) {
30665       {
30666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30667       };
30668     } catch (Dali::DaliException e) {
30669       {
30670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30671       };
30672     } catch (...) {
30673       {
30674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30675       };
30676     }
30677   }
30678
30679   jresult = (void *)result;
30680   return jresult;
30681 }
30682
30683
30684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
30685   void * jresult ;
30686   unsigned long arg1 ;
30687   Dali::HoverEvent *result = 0 ;
30688
30689   arg1 = (unsigned long)jarg1;
30690   {
30691     try {
30692       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
30693     } catch (std::out_of_range& e) {
30694       {
30695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30696       };
30697     } catch (std::exception& e) {
30698       {
30699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30700       };
30701     } catch (Dali::DaliException e) {
30702       {
30703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30704       };
30705     } catch (...) {
30706       {
30707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30708       };
30709     }
30710   }
30711
30712   jresult = (void *)result;
30713   return jresult;
30714 }
30715
30716
30717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
30718   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30719
30720   arg1 = (Dali::HoverEvent *)jarg1;
30721   {
30722     try {
30723       delete arg1;
30724     } catch (std::out_of_range& e) {
30725       {
30726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30727       };
30728     } catch (std::exception& e) {
30729       {
30730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30731       };
30732     } catch (Dali::DaliException e) {
30733       {
30734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30735       };
30736     } catch (...) {
30737       {
30738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30739       };
30740     }
30741   }
30742
30743 }
30744
30745
30746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
30747   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30748   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
30749
30750   arg1 = (Dali::HoverEvent *)jarg1;
30751   arg2 = (Dali::TouchPointContainer *)jarg2;
30752   if (arg1) (arg1)->points = *arg2;
30753 }
30754
30755
30756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
30757   void * jresult ;
30758   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30759   Dali::TouchPointContainer *result = 0 ;
30760
30761   arg1 = (Dali::HoverEvent *)jarg1;
30762   result = (Dali::TouchPointContainer *)& ((arg1)->points);
30763   jresult = (void *)result;
30764   return jresult;
30765 }
30766
30767
30768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
30769   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30770   unsigned long arg2 ;
30771
30772   arg1 = (Dali::HoverEvent *)jarg1;
30773   arg2 = (unsigned long)jarg2;
30774   if (arg1) (arg1)->time = arg2;
30775 }
30776
30777
30778 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
30779   unsigned long jresult ;
30780   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30781   unsigned long result;
30782
30783   arg1 = (Dali::HoverEvent *)jarg1;
30784   result = (unsigned long) ((arg1)->time);
30785   jresult = (unsigned long)result;
30786   return jresult;
30787 }
30788
30789
30790 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
30791   unsigned int jresult ;
30792   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30793   unsigned int result;
30794
30795   arg1 = (Dali::HoverEvent *)jarg1;
30796   {
30797     try {
30798       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
30799     } catch (std::out_of_range& e) {
30800       {
30801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30802       };
30803     } catch (std::exception& e) {
30804       {
30805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30806       };
30807     } catch (Dali::DaliException e) {
30808       {
30809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30810       };
30811     } catch (...) {
30812       {
30813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30814       };
30815     }
30816   }
30817
30818   jresult = result;
30819   return jresult;
30820 }
30821
30822
30823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
30824   void * jresult ;
30825   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30826   unsigned int arg2 ;
30827   Dali::TouchPoint *result = 0 ;
30828
30829   arg1 = (Dali::HoverEvent *)jarg1;
30830   arg2 = (unsigned int)jarg2;
30831   {
30832     try {
30833       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
30834     } catch (std::out_of_range& e) {
30835       {
30836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30837       };
30838     } catch (std::exception& e) {
30839       {
30840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30841       };
30842     } catch (Dali::DaliException e) {
30843       {
30844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30845       };
30846     } catch (...) {
30847       {
30848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30849       };
30850     }
30851   }
30852
30853   jresult = (void *)result;
30854   return jresult;
30855 }
30856
30857
30858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
30859   void * jresult ;
30860   Dali::KeyEvent *result = 0 ;
30861
30862   {
30863     try {
30864       result = (Dali::KeyEvent *)new Dali::KeyEvent();
30865     } catch (std::out_of_range& e) {
30866       {
30867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30868       };
30869     } catch (std::exception& e) {
30870       {
30871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30872       };
30873     } catch (Dali::DaliException e) {
30874       {
30875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30876       };
30877     } catch (...) {
30878       {
30879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30880       };
30881     }
30882   }
30883
30884   jresult = (void *)result;
30885   return jresult;
30886 }
30887
30888
30889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
30890   void * jresult ;
30891   std::string *arg1 = 0 ;
30892   std::string *arg2 = 0 ;
30893   int arg3 ;
30894   int arg4 ;
30895   unsigned long arg5 ;
30896   Dali::KeyEvent::State *arg6 = 0 ;
30897   Dali::KeyEvent::State temp6 ;
30898   Dali::KeyEvent *result = 0 ;
30899
30900   if (!jarg1) {
30901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
30902     return 0;
30903   }
30904   std::string arg1_str(jarg1);
30905   arg1 = &arg1_str;
30906   if (!jarg2) {
30907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
30908     return 0;
30909   }
30910   std::string arg2_str(jarg2);
30911   arg2 = &arg2_str;
30912   arg3 = (int)jarg3;
30913   arg4 = (int)jarg4;
30914   arg5 = (unsigned long)jarg5;
30915   temp6 = (Dali::KeyEvent::State)jarg6;
30916   arg6 = &temp6;
30917   {
30918     try {
30919       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
30920     } catch (std::out_of_range& e) {
30921       {
30922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30923       };
30924     } catch (std::exception& e) {
30925       {
30926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30927       };
30928     } catch (Dali::DaliException e) {
30929       {
30930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30931       };
30932     } catch (...) {
30933       {
30934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30935       };
30936     }
30937   }
30938
30939   jresult = (void *)result;
30940
30941   //argout typemap for const std::string&
30942
30943
30944   //argout typemap for const std::string&
30945
30946   return jresult;
30947 }
30948
30949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
30950   void * jresult ;
30951   Dali::KeyEvent *arg1 = 0 ;
30952   Dali::KeyEvent *result = 0 ;
30953
30954   arg1 = (Dali::KeyEvent *)jarg1;
30955   if (!arg1) {
30956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
30957     return 0;
30958   }
30959   {
30960     try {
30961       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
30962     } catch (std::out_of_range& e) {
30963       {
30964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30965       };
30966     } catch (std::exception& e) {
30967       {
30968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30969       };
30970     } catch (Dali::DaliException e) {
30971       {
30972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30973       };
30974     } catch (...) {
30975       {
30976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30977       };
30978     }
30979   }
30980
30981   jresult = (void *)result;
30982   return jresult;
30983 }
30984
30985
30986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
30987   void * jresult ;
30988   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
30989   Dali::KeyEvent *arg2 = 0 ;
30990   Dali::KeyEvent *result = 0 ;
30991
30992   arg1 = (Dali::KeyEvent *)jarg1;
30993   arg2 = (Dali::KeyEvent *)jarg2;
30994   if (!arg2) {
30995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
30996     return 0;
30997   }
30998   {
30999     try {
31000       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
31001     } catch (std::out_of_range& e) {
31002       {
31003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31004       };
31005     } catch (std::exception& e) {
31006       {
31007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31008       };
31009     } catch (Dali::DaliException e) {
31010       {
31011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31012       };
31013     } catch (...) {
31014       {
31015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31016       };
31017     }
31018   }
31019
31020   jresult = (void *)result;
31021   return jresult;
31022 }
31023
31024
31025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
31026   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31027
31028   arg1 = (Dali::KeyEvent *)jarg1;
31029   {
31030     try {
31031       delete arg1;
31032     } catch (std::out_of_range& e) {
31033       {
31034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31035       };
31036     } catch (std::exception& e) {
31037       {
31038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31039       };
31040     } catch (Dali::DaliException e) {
31041       {
31042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31043       };
31044     } catch (...) {
31045       {
31046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31047       };
31048     }
31049   }
31050
31051 }
31052
31053
31054 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
31055   unsigned int jresult ;
31056   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31057   bool result;
31058
31059   arg1 = (Dali::KeyEvent *)jarg1;
31060   {
31061     try {
31062       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
31063     } catch (std::out_of_range& e) {
31064       {
31065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31066       };
31067     } catch (std::exception& e) {
31068       {
31069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31070       };
31071     } catch (Dali::DaliException e) {
31072       {
31073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31074       };
31075     } catch (...) {
31076       {
31077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31078       };
31079     }
31080   }
31081
31082   jresult = result;
31083   return jresult;
31084 }
31085
31086
31087 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
31088   unsigned int jresult ;
31089   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31090   bool result;
31091
31092   arg1 = (Dali::KeyEvent *)jarg1;
31093   {
31094     try {
31095       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
31096     } catch (std::out_of_range& e) {
31097       {
31098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31099       };
31100     } catch (std::exception& e) {
31101       {
31102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31103       };
31104     } catch (Dali::DaliException e) {
31105       {
31106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31107       };
31108     } catch (...) {
31109       {
31110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31111       };
31112     }
31113   }
31114
31115   jresult = result;
31116   return jresult;
31117 }
31118
31119
31120 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
31121   unsigned int jresult ;
31122   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31123   bool result;
31124
31125   arg1 = (Dali::KeyEvent *)jarg1;
31126   {
31127     try {
31128       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
31129     } catch (std::out_of_range& e) {
31130       {
31131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31132       };
31133     } catch (std::exception& e) {
31134       {
31135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31136       };
31137     } catch (Dali::DaliException e) {
31138       {
31139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31140       };
31141     } catch (...) {
31142       {
31143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31144       };
31145     }
31146   }
31147
31148   jresult = result;
31149   return jresult;
31150 }
31151
31152
31153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
31154   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31155   std::string *arg2 = 0 ;
31156
31157   arg1 = (Dali::KeyEvent *)jarg1;
31158   if (!jarg2) {
31159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31160     return ;
31161   }
31162   std::string arg2_str(jarg2);
31163   arg2 = &arg2_str;
31164   if (arg1) (arg1)->keyPressedName = *arg2;
31165
31166   //argout typemap for const std::string&
31167
31168 }
31169
31170
31171 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
31172   char * jresult ;
31173   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31174   std::string *result = 0 ;
31175
31176   arg1 = (Dali::KeyEvent *)jarg1;
31177   result = (std::string *) & ((arg1)->keyPressedName);
31178   jresult = SWIG_csharp_string_callback(result->c_str());
31179   return jresult;
31180 }
31181
31182
31183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
31184   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31185   std::string *arg2 = 0 ;
31186
31187   arg1 = (Dali::KeyEvent *)jarg1;
31188   if (!jarg2) {
31189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31190     return ;
31191   }
31192   std::string arg2_str(jarg2);
31193   arg2 = &arg2_str;
31194   if (arg1) (arg1)->keyPressed = *arg2;
31195
31196   //argout typemap for const std::string&
31197
31198 }
31199
31200
31201 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
31202   char * jresult ;
31203   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31204   std::string *result = 0 ;
31205
31206   arg1 = (Dali::KeyEvent *)jarg1;
31207   result = (std::string *) & ((arg1)->keyPressed);
31208   jresult = SWIG_csharp_string_callback(result->c_str());
31209   return jresult;
31210 }
31211
31212
31213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
31214   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31215   int arg2 ;
31216
31217   arg1 = (Dali::KeyEvent *)jarg1;
31218   arg2 = (int)jarg2;
31219   if (arg1) (arg1)->keyCode = arg2;
31220 }
31221
31222
31223 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
31224   int jresult ;
31225   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31226   int result;
31227
31228   arg1 = (Dali::KeyEvent *)jarg1;
31229   result = (int) ((arg1)->keyCode);
31230   jresult = result;
31231   return jresult;
31232 }
31233
31234
31235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
31236   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31237   int arg2 ;
31238
31239   arg1 = (Dali::KeyEvent *)jarg1;
31240   arg2 = (int)jarg2;
31241   if (arg1) (arg1)->keyModifier = arg2;
31242 }
31243
31244
31245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
31246   int jresult ;
31247   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31248   int result;
31249
31250   arg1 = (Dali::KeyEvent *)jarg1;
31251   result = (int) ((arg1)->keyModifier);
31252   jresult = result;
31253   return jresult;
31254 }
31255
31256
31257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
31258   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31259   unsigned long arg2 ;
31260
31261   arg1 = (Dali::KeyEvent *)jarg1;
31262   arg2 = (unsigned long)jarg2;
31263   if (arg1) (arg1)->time = arg2;
31264 }
31265
31266
31267 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
31268   unsigned long jresult ;
31269   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31270   unsigned long result;
31271
31272   arg1 = (Dali::KeyEvent *)jarg1;
31273   result = (unsigned long) ((arg1)->time);
31274   jresult = (unsigned long)result;
31275   return jresult;
31276 }
31277
31278
31279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
31280   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31281   Dali::KeyEvent::State arg2 ;
31282
31283   arg1 = (Dali::KeyEvent *)jarg1;
31284   arg2 = (Dali::KeyEvent::State)jarg2;
31285   if (arg1) (arg1)->state = arg2;
31286 }
31287
31288
31289 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
31290   int jresult ;
31291   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31292   Dali::KeyEvent::State result;
31293
31294   arg1 = (Dali::KeyEvent *)jarg1;
31295   result = (Dali::KeyEvent::State) ((arg1)->state);
31296   jresult = (int)result;
31297   return jresult;
31298 }
31299
31300
31301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
31302   void * jresult ;
31303   Dali::LongPressGestureDetector *result = 0 ;
31304
31305   {
31306     try {
31307       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
31308     } catch (std::out_of_range& e) {
31309       {
31310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31311       };
31312     } catch (std::exception& e) {
31313       {
31314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31315       };
31316     } catch (Dali::DaliException e) {
31317       {
31318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31319       };
31320     } catch (...) {
31321       {
31322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31323       };
31324     }
31325   }
31326
31327   jresult = (void *)result;
31328   return jresult;
31329 }
31330
31331
31332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
31333   void * jresult ;
31334   Dali::LongPressGestureDetector result;
31335
31336   {
31337     try {
31338       result = Dali::LongPressGestureDetector::New();
31339     } catch (std::out_of_range& e) {
31340       {
31341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31342       };
31343     } catch (std::exception& e) {
31344       {
31345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31346       };
31347     } catch (Dali::DaliException e) {
31348       {
31349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31350       };
31351     } catch (...) {
31352       {
31353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31354       };
31355     }
31356   }
31357
31358   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31359   return jresult;
31360 }
31361
31362
31363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
31364   void * jresult ;
31365   unsigned int arg1 ;
31366   Dali::LongPressGestureDetector result;
31367
31368   arg1 = (unsigned int)jarg1;
31369   {
31370     try {
31371       result = Dali::LongPressGestureDetector::New(arg1);
31372     } catch (std::out_of_range& e) {
31373       {
31374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31375       };
31376     } catch (std::exception& e) {
31377       {
31378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31379       };
31380     } catch (Dali::DaliException e) {
31381       {
31382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31383       };
31384     } catch (...) {
31385       {
31386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31387       };
31388     }
31389   }
31390
31391   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31392   return jresult;
31393 }
31394
31395
31396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
31397   void * jresult ;
31398   unsigned int arg1 ;
31399   unsigned int arg2 ;
31400   Dali::LongPressGestureDetector result;
31401
31402   arg1 = (unsigned int)jarg1;
31403   arg2 = (unsigned int)jarg2;
31404   {
31405     try {
31406       result = Dali::LongPressGestureDetector::New(arg1,arg2);
31407     } catch (std::out_of_range& e) {
31408       {
31409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31410       };
31411     } catch (std::exception& e) {
31412       {
31413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31414       };
31415     } catch (Dali::DaliException e) {
31416       {
31417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31418       };
31419     } catch (...) {
31420       {
31421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31422       };
31423     }
31424   }
31425
31426   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31427   return jresult;
31428 }
31429
31430
31431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
31432   void * jresult ;
31433   Dali::BaseHandle arg1 ;
31434   Dali::BaseHandle *argp1 ;
31435   Dali::LongPressGestureDetector result;
31436
31437   argp1 = (Dali::BaseHandle *)jarg1;
31438   if (!argp1) {
31439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31440     return 0;
31441   }
31442   arg1 = *argp1;
31443   {
31444     try {
31445       result = Dali::LongPressGestureDetector::DownCast(arg1);
31446     } catch (std::out_of_range& e) {
31447       {
31448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31449       };
31450     } catch (std::exception& e) {
31451       {
31452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31453       };
31454     } catch (Dali::DaliException e) {
31455       {
31456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31457       };
31458     } catch (...) {
31459       {
31460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31461       };
31462     }
31463   }
31464
31465   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31466   return jresult;
31467 }
31468
31469
31470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
31471   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31472
31473   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31474   {
31475     try {
31476       delete arg1;
31477     } catch (std::out_of_range& e) {
31478       {
31479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31480       };
31481     } catch (std::exception& e) {
31482       {
31483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31484       };
31485     } catch (Dali::DaliException e) {
31486       {
31487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31488       };
31489     } catch (...) {
31490       {
31491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31492       };
31493     }
31494   }
31495
31496 }
31497
31498
31499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
31500   void * jresult ;
31501   Dali::LongPressGestureDetector *arg1 = 0 ;
31502   Dali::LongPressGestureDetector *result = 0 ;
31503
31504   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31505   if (!arg1) {
31506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31507     return 0;
31508   }
31509   {
31510     try {
31511       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
31512     } catch (std::out_of_range& e) {
31513       {
31514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31515       };
31516     } catch (std::exception& e) {
31517       {
31518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31519       };
31520     } catch (Dali::DaliException e) {
31521       {
31522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31523       };
31524     } catch (...) {
31525       {
31526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31527       };
31528     }
31529   }
31530
31531   jresult = (void *)result;
31532   return jresult;
31533 }
31534
31535
31536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
31537   void * jresult ;
31538   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31539   Dali::LongPressGestureDetector *arg2 = 0 ;
31540   Dali::LongPressGestureDetector *result = 0 ;
31541
31542   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31543   arg2 = (Dali::LongPressGestureDetector *)jarg2;
31544   if (!arg2) {
31545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31546     return 0;
31547   }
31548   {
31549     try {
31550       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
31551     } catch (std::out_of_range& e) {
31552       {
31553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31554       };
31555     } catch (std::exception& e) {
31556       {
31557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31558       };
31559     } catch (Dali::DaliException e) {
31560       {
31561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31562       };
31563     } catch (...) {
31564       {
31565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31566       };
31567     }
31568   }
31569
31570   jresult = (void *)result;
31571   return jresult;
31572 }
31573
31574
31575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
31576   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31577   unsigned int arg2 ;
31578
31579   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31580   arg2 = (unsigned int)jarg2;
31581   {
31582     try {
31583       (arg1)->SetTouchesRequired(arg2);
31584     } catch (std::out_of_range& e) {
31585       {
31586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31587       };
31588     } catch (std::exception& e) {
31589       {
31590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31591       };
31592     } catch (Dali::DaliException e) {
31593       {
31594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31595       };
31596     } catch (...) {
31597       {
31598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31599       };
31600     }
31601   }
31602
31603 }
31604
31605
31606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
31607   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31608   unsigned int arg2 ;
31609   unsigned int arg3 ;
31610
31611   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31612   arg2 = (unsigned int)jarg2;
31613   arg3 = (unsigned int)jarg3;
31614   {
31615     try {
31616       (arg1)->SetTouchesRequired(arg2,arg3);
31617     } catch (std::out_of_range& e) {
31618       {
31619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31620       };
31621     } catch (std::exception& e) {
31622       {
31623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31624       };
31625     } catch (Dali::DaliException e) {
31626       {
31627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31628       };
31629     } catch (...) {
31630       {
31631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31632       };
31633     }
31634   }
31635
31636 }
31637
31638
31639 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
31640   unsigned int jresult ;
31641   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31642   unsigned int result;
31643
31644   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31645   {
31646     try {
31647       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
31648     } catch (std::out_of_range& e) {
31649       {
31650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31651       };
31652     } catch (std::exception& e) {
31653       {
31654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31655       };
31656     } catch (Dali::DaliException e) {
31657       {
31658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31659       };
31660     } catch (...) {
31661       {
31662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31663       };
31664     }
31665   }
31666
31667   jresult = result;
31668   return jresult;
31669 }
31670
31671
31672 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
31673   unsigned int jresult ;
31674   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31675   unsigned int result;
31676
31677   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31678   {
31679     try {
31680       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
31681     } catch (std::out_of_range& e) {
31682       {
31683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31684       };
31685     } catch (std::exception& e) {
31686       {
31687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31688       };
31689     } catch (Dali::DaliException e) {
31690       {
31691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31692       };
31693     } catch (...) {
31694       {
31695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31696       };
31697     }
31698   }
31699
31700   jresult = result;
31701   return jresult;
31702 }
31703
31704
31705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
31706   void * jresult ;
31707   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31708   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
31709
31710   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31711   {
31712     try {
31713       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
31714     } catch (std::out_of_range& e) {
31715       {
31716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31717       };
31718     } catch (std::exception& e) {
31719       {
31720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31721       };
31722     } catch (Dali::DaliException e) {
31723       {
31724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31725       };
31726     } catch (...) {
31727       {
31728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31729       };
31730     }
31731   }
31732
31733   jresult = (void *)result;
31734   return jresult;
31735 }
31736
31737
31738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
31739   void * jresult ;
31740   Dali::Gesture::State arg1 ;
31741   Dali::LongPressGesture *result = 0 ;
31742
31743   arg1 = (Dali::Gesture::State)jarg1;
31744   {
31745     try {
31746       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
31747     } catch (std::out_of_range& e) {
31748       {
31749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31750       };
31751     } catch (std::exception& e) {
31752       {
31753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31754       };
31755     } catch (Dali::DaliException e) {
31756       {
31757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31758       };
31759     } catch (...) {
31760       {
31761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31762       };
31763     }
31764   }
31765
31766   jresult = (void *)result;
31767   return jresult;
31768 }
31769
31770
31771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
31772   void * jresult ;
31773   Dali::LongPressGesture *arg1 = 0 ;
31774   Dali::LongPressGesture *result = 0 ;
31775
31776   arg1 = (Dali::LongPressGesture *)jarg1;
31777   if (!arg1) {
31778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31779     return 0;
31780   }
31781   {
31782     try {
31783       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
31784     } catch (std::out_of_range& e) {
31785       {
31786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31787       };
31788     } catch (std::exception& e) {
31789       {
31790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31791       };
31792     } catch (Dali::DaliException e) {
31793       {
31794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31795       };
31796     } catch (...) {
31797       {
31798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31799       };
31800     }
31801   }
31802
31803   jresult = (void *)result;
31804   return jresult;
31805 }
31806
31807
31808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
31809   void * jresult ;
31810   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31811   Dali::LongPressGesture *arg2 = 0 ;
31812   Dali::LongPressGesture *result = 0 ;
31813
31814   arg1 = (Dali::LongPressGesture *)jarg1;
31815   arg2 = (Dali::LongPressGesture *)jarg2;
31816   if (!arg2) {
31817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31818     return 0;
31819   }
31820   {
31821     try {
31822       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
31823     } catch (std::out_of_range& e) {
31824       {
31825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31826       };
31827     } catch (std::exception& e) {
31828       {
31829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31830       };
31831     } catch (Dali::DaliException e) {
31832       {
31833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31834       };
31835     } catch (...) {
31836       {
31837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31838       };
31839     }
31840   }
31841
31842   jresult = (void *)result;
31843   return jresult;
31844 }
31845
31846
31847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
31848   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31849
31850   arg1 = (Dali::LongPressGesture *)jarg1;
31851   {
31852     try {
31853       delete arg1;
31854     } catch (std::out_of_range& e) {
31855       {
31856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31857       };
31858     } catch (std::exception& e) {
31859       {
31860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31861       };
31862     } catch (Dali::DaliException e) {
31863       {
31864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31865       };
31866     } catch (...) {
31867       {
31868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31869       };
31870     }
31871   }
31872
31873 }
31874
31875
31876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
31877   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31878   unsigned int arg2 ;
31879
31880   arg1 = (Dali::LongPressGesture *)jarg1;
31881   arg2 = (unsigned int)jarg2;
31882   if (arg1) (arg1)->numberOfTouches = arg2;
31883 }
31884
31885
31886 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
31887   unsigned int jresult ;
31888   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31889   unsigned int result;
31890
31891   arg1 = (Dali::LongPressGesture *)jarg1;
31892   result = (unsigned int) ((arg1)->numberOfTouches);
31893   jresult = result;
31894   return jresult;
31895 }
31896
31897
31898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
31899   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31900   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
31901
31902   arg1 = (Dali::LongPressGesture *)jarg1;
31903   arg2 = (Dali::Vector2 *)jarg2;
31904   if (arg1) (arg1)->screenPoint = *arg2;
31905 }
31906
31907
31908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
31909   void * jresult ;
31910   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31911   Dali::Vector2 *result = 0 ;
31912
31913   arg1 = (Dali::LongPressGesture *)jarg1;
31914   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
31915   jresult = (void *)result;
31916   return jresult;
31917 }
31918
31919
31920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
31921   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31922   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
31923
31924   arg1 = (Dali::LongPressGesture *)jarg1;
31925   arg2 = (Dali::Vector2 *)jarg2;
31926   if (arg1) (arg1)->localPoint = *arg2;
31927 }
31928
31929
31930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
31931   void * jresult ;
31932   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31933   Dali::Vector2 *result = 0 ;
31934
31935   arg1 = (Dali::LongPressGesture *)jarg1;
31936   result = (Dali::Vector2 *)& ((arg1)->localPoint);
31937   jresult = (void *)result;
31938   return jresult;
31939 }
31940
31941
31942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
31943   void * jresult ;
31944   Dali::WheelEvent *result = 0 ;
31945
31946   {
31947     try {
31948       result = (Dali::WheelEvent *)new Dali::WheelEvent();
31949     } catch (std::out_of_range& e) {
31950       {
31951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31952       };
31953     } catch (std::exception& e) {
31954       {
31955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31956       };
31957     } catch (Dali::DaliException e) {
31958       {
31959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31960       };
31961     } catch (...) {
31962       {
31963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31964       };
31965     }
31966   }
31967
31968   jresult = (void *)result;
31969   return jresult;
31970 }
31971
31972
31973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
31974   void * jresult ;
31975   Dali::WheelEvent::Type arg1 ;
31976   int arg2 ;
31977   unsigned int arg3 ;
31978   Dali::Vector2 arg4 ;
31979   int arg5 ;
31980   unsigned int arg6 ;
31981   Dali::Vector2 *argp4 ;
31982   Dali::WheelEvent *result = 0 ;
31983
31984   arg1 = (Dali::WheelEvent::Type)jarg1;
31985   arg2 = (int)jarg2;
31986   arg3 = (unsigned int)jarg3;
31987   argp4 = (Dali::Vector2 *)jarg4;
31988   if (!argp4) {
31989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
31990     return 0;
31991   }
31992   arg4 = *argp4;
31993   arg5 = (int)jarg5;
31994   arg6 = (unsigned int)jarg6;
31995   {
31996     try {
31997       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
31998     } catch (std::out_of_range& e) {
31999       {
32000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32001       };
32002     } catch (std::exception& e) {
32003       {
32004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32005       };
32006     } catch (Dali::DaliException e) {
32007       {
32008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32009       };
32010     } catch (...) {
32011       {
32012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32013       };
32014     }
32015   }
32016
32017   jresult = (void *)result;
32018   return jresult;
32019 }
32020
32021
32022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
32023   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32024
32025   arg1 = (Dali::WheelEvent *)jarg1;
32026   {
32027     try {
32028       delete arg1;
32029     } catch (std::out_of_range& e) {
32030       {
32031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32032       };
32033     } catch (std::exception& e) {
32034       {
32035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32036       };
32037     } catch (Dali::DaliException e) {
32038       {
32039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32040       };
32041     } catch (...) {
32042       {
32043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32044       };
32045     }
32046   }
32047
32048 }
32049
32050
32051 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
32052   unsigned int jresult ;
32053   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32054   bool result;
32055
32056   arg1 = (Dali::WheelEvent *)jarg1;
32057   {
32058     try {
32059       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
32060     } catch (std::out_of_range& e) {
32061       {
32062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32063       };
32064     } catch (std::exception& e) {
32065       {
32066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32067       };
32068     } catch (Dali::DaliException e) {
32069       {
32070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32071       };
32072     } catch (...) {
32073       {
32074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32075       };
32076     }
32077   }
32078
32079   jresult = result;
32080   return jresult;
32081 }
32082
32083
32084 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
32085   unsigned int jresult ;
32086   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32087   bool result;
32088
32089   arg1 = (Dali::WheelEvent *)jarg1;
32090   {
32091     try {
32092       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
32093     } catch (std::out_of_range& e) {
32094       {
32095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32096       };
32097     } catch (std::exception& e) {
32098       {
32099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32100       };
32101     } catch (Dali::DaliException e) {
32102       {
32103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32104       };
32105     } catch (...) {
32106       {
32107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32108       };
32109     }
32110   }
32111
32112   jresult = result;
32113   return jresult;
32114 }
32115
32116
32117 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
32118   unsigned int jresult ;
32119   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32120   bool result;
32121
32122   arg1 = (Dali::WheelEvent *)jarg1;
32123   {
32124     try {
32125       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
32126     } catch (std::out_of_range& e) {
32127       {
32128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32129       };
32130     } catch (std::exception& e) {
32131       {
32132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32133       };
32134     } catch (Dali::DaliException e) {
32135       {
32136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32137       };
32138     } catch (...) {
32139       {
32140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32141       };
32142     }
32143   }
32144
32145   jresult = result;
32146   return jresult;
32147 }
32148
32149
32150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
32151   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32152   Dali::WheelEvent::Type arg2 ;
32153
32154   arg1 = (Dali::WheelEvent *)jarg1;
32155   arg2 = (Dali::WheelEvent::Type)jarg2;
32156   if (arg1) (arg1)->type = arg2;
32157 }
32158
32159
32160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
32161   int jresult ;
32162   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32163   Dali::WheelEvent::Type result;
32164
32165   arg1 = (Dali::WheelEvent *)jarg1;
32166   result = (Dali::WheelEvent::Type) ((arg1)->type);
32167   jresult = (int)result;
32168   return jresult;
32169 }
32170
32171
32172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
32173   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32174   int arg2 ;
32175
32176   arg1 = (Dali::WheelEvent *)jarg1;
32177   arg2 = (int)jarg2;
32178   if (arg1) (arg1)->direction = arg2;
32179 }
32180
32181
32182 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
32183   int jresult ;
32184   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32185   int result;
32186
32187   arg1 = (Dali::WheelEvent *)jarg1;
32188   result = (int) ((arg1)->direction);
32189   jresult = result;
32190   return jresult;
32191 }
32192
32193
32194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
32195   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32196   unsigned int arg2 ;
32197
32198   arg1 = (Dali::WheelEvent *)jarg1;
32199   arg2 = (unsigned int)jarg2;
32200   if (arg1) (arg1)->modifiers = arg2;
32201 }
32202
32203
32204 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
32205   unsigned int jresult ;
32206   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32207   unsigned int result;
32208
32209   arg1 = (Dali::WheelEvent *)jarg1;
32210   result = (unsigned int) ((arg1)->modifiers);
32211   jresult = result;
32212   return jresult;
32213 }
32214
32215
32216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
32217   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32218   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32219
32220   arg1 = (Dali::WheelEvent *)jarg1;
32221   arg2 = (Dali::Vector2 *)jarg2;
32222   if (arg1) (arg1)->point = *arg2;
32223 }
32224
32225
32226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
32227   void * jresult ;
32228   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32229   Dali::Vector2 *result = 0 ;
32230
32231   arg1 = (Dali::WheelEvent *)jarg1;
32232   result = (Dali::Vector2 *)& ((arg1)->point);
32233   jresult = (void *)result;
32234   return jresult;
32235 }
32236
32237
32238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
32239   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32240   int arg2 ;
32241
32242   arg1 = (Dali::WheelEvent *)jarg1;
32243   arg2 = (int)jarg2;
32244   if (arg1) (arg1)->z = arg2;
32245 }
32246
32247
32248 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
32249   int jresult ;
32250   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32251   int result;
32252
32253   arg1 = (Dali::WheelEvent *)jarg1;
32254   result = (int) ((arg1)->z);
32255   jresult = result;
32256   return jresult;
32257 }
32258
32259
32260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
32261   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32262   unsigned int arg2 ;
32263
32264   arg1 = (Dali::WheelEvent *)jarg1;
32265   arg2 = (unsigned int)jarg2;
32266   if (arg1) (arg1)->timeStamp = arg2;
32267 }
32268
32269
32270 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
32271   unsigned int jresult ;
32272   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32273   unsigned int result;
32274
32275   arg1 = (Dali::WheelEvent *)jarg1;
32276   result = (unsigned int) ((arg1)->timeStamp);
32277   jresult = result;
32278   return jresult;
32279 }
32280
32281 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
32282   char * jresult ;
32283   Dali::KeyEvent *arg1 = 0 ;
32284   std::string result;
32285
32286   arg1 = (Dali::KeyEvent *)jarg1;
32287   if (!arg1) {
32288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32289     return 0;
32290   }
32291   {
32292     try {
32293       result = arg1->GetDeviceName();
32294     } catch (std::out_of_range& e) {
32295       {
32296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32297       };
32298     } catch (std::exception& e) {
32299       {
32300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32301       };
32302     } catch (Dali::DaliException e) {
32303       {
32304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32305       };
32306     } catch (...) {
32307       {
32308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32309       };
32310     }
32311   }
32312
32313   jresult = SWIG_csharp_string_callback((&result)->c_str());
32314   return jresult;
32315 }
32316
32317 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
32318   int jresult ;
32319   Dali::KeyEvent *arg1 = 0 ;
32320   Dali::Device::Class::Type result;
32321
32322   arg1 = (Dali::KeyEvent *)jarg1;
32323   if (!arg1) {
32324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32325     return 0;
32326   }
32327   {
32328     try {
32329       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
32330     } catch (std::out_of_range& e) {
32331       {
32332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32333       };
32334     } catch (std::exception& e) {
32335       {
32336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32337       };
32338     } catch (Dali::DaliException e) {
32339       {
32340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32341       };
32342     } catch (...) {
32343       {
32344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32345       };
32346     }
32347   }
32348
32349   jresult = (int)result;
32350   return jresult;
32351 }
32352
32353 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
32354   int jresult ;
32355   Dali::KeyEvent *arg1 = 0 ;
32356   Dali::Device::Subclass::Type result;
32357
32358   arg1 = (Dali::KeyEvent *)jarg1;
32359   if (!arg1) {
32360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32361     return 0;
32362   }
32363   {
32364     try {
32365       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
32366     } catch (std::out_of_range& e) {
32367       {
32368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32369       };
32370     } catch (std::exception& e) {
32371       {
32372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32373       };
32374     } catch (Dali::DaliException e) {
32375       {
32376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32377       };
32378     } catch (...) {
32379       {
32380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32381       };
32382     }
32383   }
32384
32385   jresult = (int)result;
32386   return jresult;
32387 }
32388
32389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32390   Dali::Actor arg1 ;
32391   Dali::Actor *argp1 ;
32392
32393   argp1 = (Dali::Actor *)jarg1;
32394   if (!argp1) {
32395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32396     return ;
32397   }
32398   arg1 = *argp1;
32399   {
32400     try {
32401       arg1.Raise();
32402     } catch (std::out_of_range& e) {
32403       {
32404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32405       };
32406     } catch (std::exception& e) {
32407       {
32408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32409       };
32410     } catch (Dali::DaliException e) {
32411       {
32412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32413       };
32414     } catch (...) {
32415       {
32416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32417       };
32418     }
32419   }
32420
32421 }
32422
32423
32424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32425   Dali::Actor arg1 ;
32426   Dali::Actor *argp1 ;
32427
32428   argp1 = (Dali::Actor *)jarg1;
32429   if (!argp1) {
32430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32431     return ;
32432   }
32433   arg1 = *argp1;
32434   {
32435     try {
32436       arg1.Lower();
32437     } catch (std::out_of_range& e) {
32438       {
32439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32440       };
32441     } catch (std::exception& e) {
32442       {
32443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32444       };
32445     } catch (Dali::DaliException e) {
32446       {
32447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32448       };
32449     } catch (...) {
32450       {
32451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32452       };
32453     }
32454   }
32455
32456 }
32457
32458
32459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32460   Dali::Actor arg1 ;
32461   Dali::Actor *argp1 ;
32462
32463   argp1 = (Dali::Actor *)jarg1;
32464   if (!argp1) {
32465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32466     return ;
32467   }
32468   arg1 = *argp1;
32469   {
32470     try {
32471       arg1.RaiseToTop();
32472     } catch (std::out_of_range& e) {
32473       {
32474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32475       };
32476     } catch (std::exception& e) {
32477       {
32478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32479       };
32480     } catch (Dali::DaliException e) {
32481       {
32482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32483       };
32484     } catch (...) {
32485       {
32486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32487       };
32488     }
32489   }
32490
32491 }
32492
32493
32494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32495   Dali::Actor arg1 ;
32496   Dali::Actor *argp1 ;
32497
32498   argp1 = (Dali::Actor *)jarg1;
32499   if (!argp1) {
32500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32501     return ;
32502   }
32503   arg1 = *argp1;
32504   {
32505     try {
32506       arg1.LowerToBottom();
32507     } catch (std::out_of_range& e) {
32508       {
32509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32510       };
32511     } catch (std::exception& e) {
32512       {
32513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32514       };
32515     } catch (Dali::DaliException e) {
32516       {
32517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32518       };
32519     } catch (...) {
32520       {
32521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32522       };
32523     }
32524   }
32525
32526 }
32527
32528
32529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32530   Dali::Actor arg1 ;
32531   Dali::Actor arg2 ;
32532   Dali::Actor *argp1 ;
32533   Dali::Actor *argp2 ;
32534
32535   argp1 = (Dali::Actor *)jarg1;
32536   if (!argp1) {
32537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32538     return ;
32539   }
32540   arg1 = *argp1;
32541   argp2 = (Dali::Actor *)jarg2;
32542   if (!argp2) {
32543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32544     return ;
32545   }
32546   arg2 = *argp2;
32547   {
32548     try {
32549       arg1.RaiseAbove(arg2);
32550     } catch (std::out_of_range& e) {
32551       {
32552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32553       };
32554     } catch (std::exception& e) {
32555       {
32556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32557       };
32558     } catch (Dali::DaliException e) {
32559       {
32560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32561       };
32562     } catch (...) {
32563       {
32564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32565       };
32566     }
32567   }
32568
32569 }
32570
32571
32572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32573   Dali::Actor arg1 ;
32574   Dali::Actor arg2 ;
32575   Dali::Actor *argp1 ;
32576   Dali::Actor *argp2 ;
32577
32578   argp1 = (Dali::Actor *)jarg1;
32579   if (!argp1) {
32580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32581     return ;
32582   }
32583   arg1 = *argp1;
32584   argp2 = (Dali::Actor *)jarg2;
32585   if (!argp2) {
32586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32587     return ;
32588   }
32589   arg2 = *argp2;
32590   {
32591     try {
32592       arg1.LowerBelow(arg2);
32593     } catch (std::out_of_range& e) {
32594       {
32595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32596       };
32597     } catch (std::exception& e) {
32598       {
32599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32600       };
32601     } catch (Dali::DaliException e) {
32602       {
32603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32604       };
32605     } catch (...) {
32606       {
32607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32608       };
32609     }
32610   }
32611
32612 }
32613
32614
32615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
32616   void * jresult ;
32617   Dali::Actor arg1 ;
32618   Dali::Actor *argp1 ;
32619   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
32620
32621   argp1 = (Dali::Actor *)jarg1;
32622   if (!argp1) {
32623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32624     return 0;
32625   }
32626   arg1 = *argp1;
32627   {
32628     try {
32629       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
32630     } catch (std::out_of_range& e) {
32631       {
32632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32633       };
32634     } catch (std::exception& e) {
32635       {
32636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32637       };
32638     } catch (Dali::DaliException e) {
32639       {
32640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32641       };
32642     } catch (...) {
32643       {
32644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32645       };
32646     }
32647   }
32648
32649   jresult = (void *)result;
32650   return jresult;
32651 }
32652
32653
32654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
32655   void * jresult ;
32656   Dali::Actor *arg1 ;
32657   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
32658
32659   arg1 = (Dali::Actor *)jarg1;
32660   {
32661     try {
32662       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
32663     } catch (std::out_of_range& e) {
32664       {
32665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32666       };
32667     } catch (std::exception& e) {
32668       {
32669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32670       };
32671     } catch (Dali::DaliException e) {
32672       {
32673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32674       };
32675     } catch (...) {
32676       {
32677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32678       };
32679     }
32680   }
32681
32682   jresult = (void *)result;
32683   return jresult;
32684 }
32685
32686
32687 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
32688   int jresult ;
32689   int result;
32690
32691   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
32692   jresult = (int)result;
32693   return jresult;
32694 }
32695
32696
32697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
32698   int jresult ;
32699   int result;
32700
32701   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
32702   jresult = (int)result;
32703   return jresult;
32704 }
32705
32706
32707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
32708   int jresult ;
32709   int result;
32710
32711   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
32712   jresult = (int)result;
32713   return jresult;
32714 }
32715
32716
32717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
32718   int jresult ;
32719   int result;
32720
32721   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
32722   jresult = (int)result;
32723   return jresult;
32724 }
32725
32726
32727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
32728   int jresult ;
32729   int result;
32730
32731   result = (int)Dali::Actor::Property::ANCHOR_POINT;
32732   jresult = (int)result;
32733   return jresult;
32734 }
32735
32736
32737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
32738   int jresult ;
32739   int result;
32740
32741   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
32742   jresult = (int)result;
32743   return jresult;
32744 }
32745
32746
32747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
32748   int jresult ;
32749   int result;
32750
32751   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
32752   jresult = (int)result;
32753   return jresult;
32754 }
32755
32756
32757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
32758   int jresult ;
32759   int result;
32760
32761   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
32762   jresult = (int)result;
32763   return jresult;
32764 }
32765
32766
32767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
32768   int jresult ;
32769   int result;
32770
32771   result = (int)Dali::Actor::Property::SIZE;
32772   jresult = (int)result;
32773   return jresult;
32774 }
32775
32776
32777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
32778   int jresult ;
32779   int result;
32780
32781   result = (int)Dali::Actor::Property::SIZE_WIDTH;
32782   jresult = (int)result;
32783   return jresult;
32784 }
32785
32786
32787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
32788   int jresult ;
32789   int result;
32790
32791   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
32792   jresult = (int)result;
32793   return jresult;
32794 }
32795
32796
32797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
32798   int jresult ;
32799   int result;
32800
32801   result = (int)Dali::Actor::Property::SIZE_DEPTH;
32802   jresult = (int)result;
32803   return jresult;
32804 }
32805
32806
32807 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
32808   int jresult ;
32809   int result;
32810
32811   result = (int)Dali::Actor::Property::POSITION;
32812   jresult = (int)result;
32813   return jresult;
32814 }
32815
32816
32817 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
32818   int jresult ;
32819   int result;
32820
32821   result = (int)Dali::Actor::Property::POSITION_X;
32822   jresult = (int)result;
32823   return jresult;
32824 }
32825
32826
32827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
32828   int jresult ;
32829   int result;
32830
32831   result = (int)Dali::Actor::Property::POSITION_Y;
32832   jresult = (int)result;
32833   return jresult;
32834 }
32835
32836
32837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
32838   int jresult ;
32839   int result;
32840
32841   result = (int)Dali::Actor::Property::POSITION_Z;
32842   jresult = (int)result;
32843   return jresult;
32844 }
32845
32846
32847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
32848   int jresult ;
32849   int result;
32850
32851   result = (int)Dali::Actor::Property::WORLD_POSITION;
32852   jresult = (int)result;
32853   return jresult;
32854 }
32855
32856
32857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
32858   int jresult ;
32859   int result;
32860
32861   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
32862   jresult = (int)result;
32863   return jresult;
32864 }
32865
32866
32867 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
32868   int jresult ;
32869   int result;
32870
32871   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
32872   jresult = (int)result;
32873   return jresult;
32874 }
32875
32876
32877 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
32878   int jresult ;
32879   int result;
32880
32881   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
32882   jresult = (int)result;
32883   return jresult;
32884 }
32885
32886
32887 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
32888   int jresult ;
32889   int result;
32890
32891   result = (int)Dali::Actor::Property::ORIENTATION;
32892   jresult = (int)result;
32893   return jresult;
32894 }
32895
32896
32897 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
32898   int jresult ;
32899   int result;
32900
32901   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
32902   jresult = (int)result;
32903   return jresult;
32904 }
32905
32906
32907 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
32908   int jresult ;
32909   int result;
32910
32911   result = (int)Dali::Actor::Property::SCALE;
32912   jresult = (int)result;
32913   return jresult;
32914 }
32915
32916
32917 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
32918   int jresult ;
32919   int result;
32920
32921   result = (int)Dali::Actor::Property::SCALE_X;
32922   jresult = (int)result;
32923   return jresult;
32924 }
32925
32926
32927 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
32928   int jresult ;
32929   int result;
32930
32931   result = (int)Dali::Actor::Property::SCALE_Y;
32932   jresult = (int)result;
32933   return jresult;
32934 }
32935
32936
32937 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
32938   int jresult ;
32939   int result;
32940
32941   result = (int)Dali::Actor::Property::SCALE_Z;
32942   jresult = (int)result;
32943   return jresult;
32944 }
32945
32946
32947 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
32948   int jresult ;
32949   int result;
32950
32951   result = (int)Dali::Actor::Property::WORLD_SCALE;
32952   jresult = (int)result;
32953   return jresult;
32954 }
32955
32956
32957 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
32958   int jresult ;
32959   int result;
32960
32961   result = (int)Dali::Actor::Property::VISIBLE;
32962   jresult = (int)result;
32963   return jresult;
32964 }
32965
32966
32967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
32968   int jresult ;
32969   int result;
32970
32971   result = (int)Dali::Actor::Property::COLOR;
32972   jresult = (int)result;
32973   return jresult;
32974 }
32975
32976
32977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
32978   int jresult ;
32979   int result;
32980
32981   result = (int)Dali::Actor::Property::COLOR_RED;
32982   jresult = (int)result;
32983   return jresult;
32984 }
32985
32986
32987 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
32988   int jresult ;
32989   int result;
32990
32991   result = (int)Dali::Actor::Property::COLOR_GREEN;
32992   jresult = (int)result;
32993   return jresult;
32994 }
32995
32996
32997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
32998   int jresult ;
32999   int result;
33000
33001   result = (int)Dali::Actor::Property::COLOR_BLUE;
33002   jresult = (int)result;
33003   return jresult;
33004 }
33005
33006
33007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
33008   int jresult ;
33009   int result;
33010
33011   result = (int)Dali::Actor::Property::COLOR_ALPHA;
33012   jresult = (int)result;
33013   return jresult;
33014 }
33015
33016
33017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
33018   int jresult ;
33019   int result;
33020
33021   result = (int)Dali::Actor::Property::WORLD_COLOR;
33022   jresult = (int)result;
33023   return jresult;
33024 }
33025
33026
33027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
33028   int jresult ;
33029   int result;
33030
33031   result = (int)Dali::Actor::Property::WORLD_MATRIX;
33032   jresult = (int)result;
33033   return jresult;
33034 }
33035
33036
33037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
33038   int jresult ;
33039   int result;
33040
33041   result = (int)Dali::Actor::Property::NAME;
33042   jresult = (int)result;
33043   return jresult;
33044 }
33045
33046
33047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
33048   int jresult ;
33049   int result;
33050
33051   result = (int)Dali::Actor::Property::SENSITIVE;
33052   jresult = (int)result;
33053   return jresult;
33054 }
33055
33056
33057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
33058   int jresult ;
33059   int result;
33060
33061   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
33062   jresult = (int)result;
33063   return jresult;
33064 }
33065
33066
33067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
33068   int jresult ;
33069   int result;
33070
33071   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
33072   jresult = (int)result;
33073   return jresult;
33074 }
33075
33076
33077 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
33078   int jresult ;
33079   int result;
33080
33081   result = (int)Dali::Actor::Property::INHERIT_SCALE;
33082   jresult = (int)result;
33083   return jresult;
33084 }
33085
33086
33087 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
33088   int jresult ;
33089   int result;
33090
33091   result = (int)Dali::Actor::Property::COLOR_MODE;
33092   jresult = (int)result;
33093   return jresult;
33094 }
33095
33096
33097 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_INHERITANCE_get() {
33098   int jresult ;
33099   int result;
33100
33101   result = (int)Dali::Actor::Property::POSITION_INHERITANCE;
33102   jresult = (int)result;
33103   return jresult;
33104 }
33105
33106
33107 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
33108   int jresult ;
33109   int result;
33110
33111   result = (int)Dali::Actor::Property::DRAW_MODE;
33112   jresult = (int)result;
33113   return jresult;
33114 }
33115
33116
33117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
33118   int jresult ;
33119   int result;
33120
33121   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
33122   jresult = (int)result;
33123   return jresult;
33124 }
33125
33126
33127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
33128   int jresult ;
33129   int result;
33130
33131   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
33132   jresult = (int)result;
33133   return jresult;
33134 }
33135
33136
33137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
33138   int jresult ;
33139   int result;
33140
33141   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
33142   jresult = (int)result;
33143   return jresult;
33144 }
33145
33146
33147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
33148   int jresult ;
33149   int result;
33150
33151   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
33152   jresult = (int)result;
33153   return jresult;
33154 }
33155
33156
33157 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
33158   int jresult ;
33159   int result;
33160
33161   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
33162   jresult = (int)result;
33163   return jresult;
33164 }
33165
33166
33167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
33168   int jresult ;
33169   int result;
33170
33171   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
33172   jresult = (int)result;
33173   return jresult;
33174 }
33175
33176
33177 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
33178   int jresult ;
33179   int result;
33180
33181   result = (int)Dali::Actor::Property::PADDING;
33182   jresult = (int)result;
33183   return jresult;
33184 }
33185
33186
33187 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
33188   int jresult ;
33189   int result;
33190
33191   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
33192   jresult = (int)result;
33193   return jresult;
33194 }
33195
33196
33197 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
33198   int jresult ;
33199   int result;
33200
33201   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
33202   jresult = (int)result;
33203   return jresult;
33204 }
33205
33206
33207 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
33208   int jresult ;
33209   int result;
33210
33211   result = (int)Dali::Actor::Property::INHERIT_POSITION;
33212   jresult = (int)result;
33213   return jresult;
33214 }
33215
33216
33217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
33218   int jresult ;
33219   int result;
33220
33221   result = (int)Dali::Actor::Property::CLIPPING_MODE;
33222   jresult = (int)result;
33223   return jresult;
33224 }
33225
33226
33227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
33228   void * jresult ;
33229   Dali::Actor::Property *result = 0 ;
33230
33231   {
33232     try {
33233       result = (Dali::Actor::Property *)new Dali::Actor::Property();
33234     } catch (std::out_of_range& e) {
33235       {
33236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33237       };
33238     } catch (std::exception& e) {
33239       {
33240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33241       };
33242     } catch (Dali::DaliException e) {
33243       {
33244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33245       };
33246     } catch (...) {
33247       {
33248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33249       };
33250     }
33251   }
33252
33253   jresult = (void *)result;
33254   return jresult;
33255 }
33256
33257
33258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
33259   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
33260
33261   arg1 = (Dali::Actor::Property *)jarg1;
33262   {
33263     try {
33264       delete arg1;
33265     } catch (std::out_of_range& e) {
33266       {
33267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33268       };
33269     } catch (std::exception& e) {
33270       {
33271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33272       };
33273     } catch (Dali::DaliException e) {
33274       {
33275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33276       };
33277     } catch (...) {
33278       {
33279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33280       };
33281     }
33282   }
33283
33284 }
33285
33286
33287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
33288   void * jresult ;
33289   Dali::Actor *result = 0 ;
33290
33291   {
33292     try {
33293       result = (Dali::Actor *)new Dali::Actor();
33294     } catch (std::out_of_range& e) {
33295       {
33296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33297       };
33298     } catch (std::exception& e) {
33299       {
33300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33301       };
33302     } catch (Dali::DaliException e) {
33303       {
33304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33305       };
33306     } catch (...) {
33307       {
33308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33309       };
33310     }
33311   }
33312
33313   jresult = (void *)result;
33314   return jresult;
33315 }
33316
33317
33318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
33319   void * jresult ;
33320   Dali::Actor result;
33321
33322   {
33323     try {
33324       result = Dali::Actor::New();
33325     } catch (std::out_of_range& e) {
33326       {
33327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33328       };
33329     } catch (std::exception& e) {
33330       {
33331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33332       };
33333     } catch (Dali::DaliException e) {
33334       {
33335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33336       };
33337     } catch (...) {
33338       {
33339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33340       };
33341     }
33342   }
33343
33344   jresult = new Dali::Actor((const Dali::Actor &)result);
33345   return jresult;
33346 }
33347
33348
33349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
33350   void * jresult ;
33351   Dali::BaseHandle arg1 ;
33352   Dali::BaseHandle *argp1 ;
33353   Dali::Actor result;
33354
33355   argp1 = (Dali::BaseHandle *)jarg1;
33356   if (!argp1) {
33357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33358     return 0;
33359   }
33360   arg1 = *argp1;
33361   {
33362     try {
33363       result = Dali::Actor::DownCast(arg1);
33364     } catch (std::out_of_range& e) {
33365       {
33366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33367       };
33368     } catch (std::exception& e) {
33369       {
33370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33371       };
33372     } catch (Dali::DaliException e) {
33373       {
33374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33375       };
33376     } catch (...) {
33377       {
33378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33379       };
33380     }
33381   }
33382
33383   jresult = new Dali::Actor((const Dali::Actor &)result);
33384   return jresult;
33385 }
33386
33387
33388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
33389   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33390
33391   arg1 = (Dali::Actor *)jarg1;
33392   {
33393     try {
33394       delete arg1;
33395     } catch (std::out_of_range& e) {
33396       {
33397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33398       };
33399     } catch (std::exception& e) {
33400       {
33401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33402       };
33403     } catch (Dali::DaliException e) {
33404       {
33405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33406       };
33407     } catch (...) {
33408       {
33409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33410       };
33411     }
33412   }
33413
33414 }
33415
33416
33417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
33418   void * jresult ;
33419   Dali::Actor *arg1 = 0 ;
33420   Dali::Actor *result = 0 ;
33421
33422   arg1 = (Dali::Actor *)jarg1;
33423   if (!arg1) {
33424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33425     return 0;
33426   }
33427   {
33428     try {
33429       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
33430     } catch (std::out_of_range& e) {
33431       {
33432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33433       };
33434     } catch (std::exception& e) {
33435       {
33436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33437       };
33438     } catch (Dali::DaliException e) {
33439       {
33440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33441       };
33442     } catch (...) {
33443       {
33444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33445       };
33446     }
33447   }
33448
33449   jresult = (void *)result;
33450   return jresult;
33451 }
33452
33453
33454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
33455   void * jresult ;
33456   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33457   Dali::Actor *arg2 = 0 ;
33458   Dali::Actor *result = 0 ;
33459
33460   arg1 = (Dali::Actor *)jarg1;
33461   arg2 = (Dali::Actor *)jarg2;
33462   if (!arg2) {
33463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33464     return 0;
33465   }
33466   {
33467     try {
33468       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
33469     } catch (std::out_of_range& e) {
33470       {
33471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33472       };
33473     } catch (std::exception& e) {
33474       {
33475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33476       };
33477     } catch (Dali::DaliException e) {
33478       {
33479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33480       };
33481     } catch (...) {
33482       {
33483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33484       };
33485     }
33486   }
33487
33488   jresult = (void *)result;
33489   return jresult;
33490 }
33491
33492
33493 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
33494   char * jresult ;
33495   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33496   std::string *result = 0 ;
33497
33498   arg1 = (Dali::Actor *)jarg1;
33499   {
33500     try {
33501       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
33502     } catch (std::out_of_range& e) {
33503       {
33504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33505       };
33506     } catch (std::exception& e) {
33507       {
33508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33509       };
33510     } catch (Dali::DaliException e) {
33511       {
33512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33513       };
33514     } catch (...) {
33515       {
33516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33517       };
33518     }
33519   }
33520
33521   jresult = SWIG_csharp_string_callback(result->c_str());
33522   return jresult;
33523 }
33524
33525
33526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
33527   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33528   std::string *arg2 = 0 ;
33529
33530   arg1 = (Dali::Actor *)jarg1;
33531   if (!jarg2) {
33532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33533     return ;
33534   }
33535   std::string arg2_str(jarg2);
33536   arg2 = &arg2_str;
33537   {
33538     try {
33539       (arg1)->SetName((std::string const &)*arg2);
33540     } catch (std::out_of_range& e) {
33541       {
33542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33543       };
33544     } catch (std::exception& e) {
33545       {
33546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33547       };
33548     } catch (Dali::DaliException e) {
33549       {
33550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33551       };
33552     } catch (...) {
33553       {
33554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33555       };
33556     }
33557   }
33558
33559
33560   //argout typemap for const std::string&
33561
33562 }
33563
33564
33565 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
33566   unsigned int jresult ;
33567   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33568   unsigned int result;
33569
33570   arg1 = (Dali::Actor *)jarg1;
33571   {
33572     try {
33573       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
33574     } catch (std::out_of_range& e) {
33575       {
33576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33577       };
33578     } catch (std::exception& e) {
33579       {
33580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33581       };
33582     } catch (Dali::DaliException e) {
33583       {
33584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33585       };
33586     } catch (...) {
33587       {
33588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33589       };
33590     }
33591   }
33592
33593   jresult = result;
33594   return jresult;
33595 }
33596
33597
33598 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
33599   unsigned int jresult ;
33600   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33601   bool result;
33602
33603   arg1 = (Dali::Actor *)jarg1;
33604   {
33605     try {
33606       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
33607     } catch (std::out_of_range& e) {
33608       {
33609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33610       };
33611     } catch (std::exception& e) {
33612       {
33613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33614       };
33615     } catch (Dali::DaliException e) {
33616       {
33617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33618       };
33619     } catch (...) {
33620       {
33621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33622       };
33623     }
33624   }
33625
33626   jresult = result;
33627   return jresult;
33628 }
33629
33630
33631 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
33632   unsigned int jresult ;
33633   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33634   bool result;
33635
33636   arg1 = (Dali::Actor *)jarg1;
33637   {
33638     try {
33639       result = (bool)((Dali::Actor const *)arg1)->OnStage();
33640     } catch (std::out_of_range& e) {
33641       {
33642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33643       };
33644     } catch (std::exception& e) {
33645       {
33646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33647       };
33648     } catch (Dali::DaliException e) {
33649       {
33650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33651       };
33652     } catch (...) {
33653       {
33654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33655       };
33656     }
33657   }
33658
33659   jresult = result;
33660   return jresult;
33661 }
33662
33663
33664 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
33665   unsigned int jresult ;
33666   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33667   bool result;
33668
33669   arg1 = (Dali::Actor *)jarg1;
33670   {
33671     try {
33672       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
33673     } catch (std::out_of_range& e) {
33674       {
33675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33676       };
33677     } catch (std::exception& e) {
33678       {
33679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33680       };
33681     } catch (Dali::DaliException e) {
33682       {
33683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33684       };
33685     } catch (...) {
33686       {
33687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33688       };
33689     }
33690   }
33691
33692   jresult = result;
33693   return jresult;
33694 }
33695
33696
33697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
33698   void * jresult ;
33699   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33700   Dali::Layer result;
33701
33702   arg1 = (Dali::Actor *)jarg1;
33703   {
33704     try {
33705       result = (arg1)->GetLayer();
33706     } catch (std::out_of_range& e) {
33707       {
33708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33709       };
33710     } catch (std::exception& e) {
33711       {
33712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33713       };
33714     } catch (Dali::DaliException e) {
33715       {
33716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33717       };
33718     } catch (...) {
33719       {
33720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33721       };
33722     }
33723   }
33724
33725   jresult = new Dali::Layer((const Dali::Layer &)result);
33726   return jresult;
33727 }
33728
33729
33730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
33731   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33732   Dali::Actor arg2 ;
33733   Dali::Actor *argp2 ;
33734
33735   arg1 = (Dali::Actor *)jarg1;
33736   argp2 = (Dali::Actor *)jarg2;
33737   if (!argp2) {
33738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33739     return ;
33740   }
33741   arg2 = *argp2;
33742   {
33743     try {
33744       (arg1)->Add(arg2);
33745     } catch (std::out_of_range& e) {
33746       {
33747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33748       };
33749     } catch (std::exception& e) {
33750       {
33751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33752       };
33753     } catch (Dali::DaliException e) {
33754       {
33755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33756       };
33757     } catch (...) {
33758       {
33759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33760       };
33761     }
33762   }
33763
33764 }
33765
33766
33767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
33768   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33769   Dali::Actor arg2 ;
33770   Dali::Actor *argp2 ;
33771
33772   arg1 = (Dali::Actor *)jarg1;
33773   argp2 = (Dali::Actor *)jarg2;
33774   if (!argp2) {
33775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33776     return ;
33777   }
33778   arg2 = *argp2;
33779   {
33780     try {
33781       (arg1)->Remove(arg2);
33782     } catch (std::out_of_range& e) {
33783       {
33784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33785       };
33786     } catch (std::exception& e) {
33787       {
33788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33789       };
33790     } catch (Dali::DaliException e) {
33791       {
33792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33793       };
33794     } catch (...) {
33795       {
33796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33797       };
33798     }
33799   }
33800
33801 }
33802
33803
33804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
33805   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33806
33807   arg1 = (Dali::Actor *)jarg1;
33808   {
33809     try {
33810       (arg1)->Unparent();
33811     } catch (std::out_of_range& e) {
33812       {
33813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33814       };
33815     } catch (std::exception& e) {
33816       {
33817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33818       };
33819     } catch (Dali::DaliException e) {
33820       {
33821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33822       };
33823     } catch (...) {
33824       {
33825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33826       };
33827     }
33828   }
33829
33830 }
33831
33832
33833 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
33834   unsigned int jresult ;
33835   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33836   unsigned int result;
33837
33838   arg1 = (Dali::Actor *)jarg1;
33839   {
33840     try {
33841       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
33842     } catch (std::out_of_range& e) {
33843       {
33844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33845       };
33846     } catch (std::exception& e) {
33847       {
33848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33849       };
33850     } catch (Dali::DaliException e) {
33851       {
33852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33853       };
33854     } catch (...) {
33855       {
33856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33857       };
33858     }
33859   }
33860
33861   jresult = result;
33862   return jresult;
33863 }
33864
33865
33866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
33867   void * jresult ;
33868   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33869   unsigned int arg2 ;
33870   Dali::Actor result;
33871
33872   arg1 = (Dali::Actor *)jarg1;
33873   arg2 = (unsigned int)jarg2;
33874   {
33875     try {
33876       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
33877     } catch (std::out_of_range& e) {
33878       {
33879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33880       };
33881     } catch (std::exception& e) {
33882       {
33883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33884       };
33885     } catch (Dali::DaliException e) {
33886       {
33887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33888       };
33889     } catch (...) {
33890       {
33891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33892       };
33893     }
33894   }
33895
33896   jresult = new Dali::Actor((const Dali::Actor &)result);
33897   return jresult;
33898 }
33899
33900
33901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
33902   void * jresult ;
33903   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33904   std::string *arg2 = 0 ;
33905   Dali::Actor result;
33906
33907   arg1 = (Dali::Actor *)jarg1;
33908   if (!jarg2) {
33909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33910     return 0;
33911   }
33912   std::string arg2_str(jarg2);
33913   arg2 = &arg2_str;
33914   {
33915     try {
33916       result = (arg1)->FindChildByName((std::string const &)*arg2);
33917     } catch (std::out_of_range& e) {
33918       {
33919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33920       };
33921     } catch (std::exception& e) {
33922       {
33923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33924       };
33925     } catch (Dali::DaliException e) {
33926       {
33927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33928       };
33929     } catch (...) {
33930       {
33931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33932       };
33933     }
33934   }
33935
33936   jresult = new Dali::Actor((const Dali::Actor &)result);
33937
33938   //argout typemap for const std::string&
33939
33940   return jresult;
33941 }
33942
33943
33944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
33945   void * jresult ;
33946   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33947   unsigned int arg2 ;
33948   Dali::Actor result;
33949
33950   arg1 = (Dali::Actor *)jarg1;
33951   arg2 = (unsigned int)jarg2;
33952   {
33953     try {
33954       result = (arg1)->FindChildById(arg2);
33955     } catch (std::out_of_range& e) {
33956       {
33957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33958       };
33959     } catch (std::exception& e) {
33960       {
33961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33962       };
33963     } catch (Dali::DaliException e) {
33964       {
33965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33966       };
33967     } catch (...) {
33968       {
33969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33970       };
33971     }
33972   }
33973
33974   jresult = new Dali::Actor((const Dali::Actor &)result);
33975   return jresult;
33976 }
33977
33978
33979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
33980   void * jresult ;
33981   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33982   Dali::Actor result;
33983
33984   arg1 = (Dali::Actor *)jarg1;
33985   {
33986     try {
33987       result = ((Dali::Actor const *)arg1)->GetParent();
33988     } catch (std::out_of_range& e) {
33989       {
33990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33991       };
33992     } catch (std::exception& e) {
33993       {
33994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33995       };
33996     } catch (Dali::DaliException e) {
33997       {
33998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33999       };
34000     } catch (...) {
34001       {
34002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34003       };
34004     }
34005   }
34006
34007   jresult = new Dali::Actor((const Dali::Actor &)result);
34008   return jresult;
34009 }
34010
34011
34012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
34013   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34014   Dali::Vector3 *arg2 = 0 ;
34015
34016   arg1 = (Dali::Actor *)jarg1;
34017   arg2 = (Dali::Vector3 *)jarg2;
34018   if (!arg2) {
34019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34020     return ;
34021   }
34022   {
34023     try {
34024       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
34025     } catch (std::out_of_range& e) {
34026       {
34027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34028       };
34029     } catch (std::exception& e) {
34030       {
34031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34032       };
34033     } catch (Dali::DaliException e) {
34034       {
34035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34036       };
34037     } catch (...) {
34038       {
34039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34040       };
34041     }
34042   }
34043
34044 }
34045
34046
34047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
34048   void * jresult ;
34049   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34050   Dali::Vector3 result;
34051
34052   arg1 = (Dali::Actor *)jarg1;
34053   {
34054     try {
34055       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
34056     } catch (std::out_of_range& e) {
34057       {
34058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34059       };
34060     } catch (std::exception& e) {
34061       {
34062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34063       };
34064     } catch (Dali::DaliException e) {
34065       {
34066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34067       };
34068     } catch (...) {
34069       {
34070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34071       };
34072     }
34073   }
34074
34075   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34076   return jresult;
34077 }
34078
34079
34080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34081   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34082   Dali::Vector3 *arg2 = 0 ;
34083
34084   arg1 = (Dali::Actor *)jarg1;
34085   arg2 = (Dali::Vector3 *)jarg2;
34086   if (!arg2) {
34087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34088     return ;
34089   }
34090   {
34091     try {
34092       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
34093     } catch (std::out_of_range& e) {
34094       {
34095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34096       };
34097     } catch (std::exception& e) {
34098       {
34099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34100       };
34101     } catch (Dali::DaliException e) {
34102       {
34103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34104       };
34105     } catch (...) {
34106       {
34107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34108       };
34109     }
34110   }
34111
34112 }
34113
34114
34115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34116   void * jresult ;
34117   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34118   Dali::Vector3 result;
34119
34120   arg1 = (Dali::Actor *)jarg1;
34121   {
34122     try {
34123       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
34124     } catch (std::out_of_range& e) {
34125       {
34126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34127       };
34128     } catch (std::exception& e) {
34129       {
34130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34131       };
34132     } catch (Dali::DaliException e) {
34133       {
34134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34135       };
34136     } catch (...) {
34137       {
34138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34139       };
34140     }
34141   }
34142
34143   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34144   return jresult;
34145 }
34146
34147
34148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34149   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34150   float arg2 ;
34151   float arg3 ;
34152
34153   arg1 = (Dali::Actor *)jarg1;
34154   arg2 = (float)jarg2;
34155   arg3 = (float)jarg3;
34156   {
34157     try {
34158       (arg1)->SetSize(arg2,arg3);
34159     } catch (std::out_of_range& e) {
34160       {
34161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34162       };
34163     } catch (std::exception& e) {
34164       {
34165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34166       };
34167     } catch (Dali::DaliException e) {
34168       {
34169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34170       };
34171     } catch (...) {
34172       {
34173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34174       };
34175     }
34176   }
34177
34178 }
34179
34180
34181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34182   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34183   float arg2 ;
34184   float arg3 ;
34185   float arg4 ;
34186
34187   arg1 = (Dali::Actor *)jarg1;
34188   arg2 = (float)jarg2;
34189   arg3 = (float)jarg3;
34190   arg4 = (float)jarg4;
34191   {
34192     try {
34193       (arg1)->SetSize(arg2,arg3,arg4);
34194     } catch (std::out_of_range& e) {
34195       {
34196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34197       };
34198     } catch (std::exception& e) {
34199       {
34200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34201       };
34202     } catch (Dali::DaliException e) {
34203       {
34204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34205       };
34206     } catch (...) {
34207       {
34208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34209       };
34210     }
34211   }
34212
34213 }
34214
34215
34216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34217   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34218   Dali::Vector2 *arg2 = 0 ;
34219
34220   arg1 = (Dali::Actor *)jarg1;
34221   arg2 = (Dali::Vector2 *)jarg2;
34222   if (!arg2) {
34223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34224     return ;
34225   }
34226   {
34227     try {
34228       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
34229     } catch (std::out_of_range& e) {
34230       {
34231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34232       };
34233     } catch (std::exception& e) {
34234       {
34235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34236       };
34237     } catch (Dali::DaliException e) {
34238       {
34239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34240       };
34241     } catch (...) {
34242       {
34243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34244       };
34245     }
34246   }
34247
34248 }
34249
34250
34251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
34252   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34253   Dali::Vector3 *arg2 = 0 ;
34254
34255   arg1 = (Dali::Actor *)jarg1;
34256   arg2 = (Dali::Vector3 *)jarg2;
34257   if (!arg2) {
34258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34259     return ;
34260   }
34261   {
34262     try {
34263       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
34264     } catch (std::out_of_range& e) {
34265       {
34266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34267       };
34268     } catch (std::exception& e) {
34269       {
34270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34271       };
34272     } catch (Dali::DaliException e) {
34273       {
34274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34275       };
34276     } catch (...) {
34277       {
34278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34279       };
34280     }
34281   }
34282
34283 }
34284
34285
34286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
34287   void * jresult ;
34288   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34289   Dali::Vector3 result;
34290
34291   arg1 = (Dali::Actor *)jarg1;
34292   {
34293     try {
34294       result = ((Dali::Actor const *)arg1)->GetTargetSize();
34295     } catch (std::out_of_range& e) {
34296       {
34297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34298       };
34299     } catch (std::exception& e) {
34300       {
34301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34302       };
34303     } catch (Dali::DaliException e) {
34304       {
34305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34306       };
34307     } catch (...) {
34308       {
34309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34310       };
34311     }
34312   }
34313
34314   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34315   return jresult;
34316 }
34317
34318
34319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
34320   void * jresult ;
34321   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34322   Dali::Vector3 result;
34323
34324   arg1 = (Dali::Actor *)jarg1;
34325   {
34326     try {
34327       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
34328     } catch (std::out_of_range& e) {
34329       {
34330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34331       };
34332     } catch (std::exception& e) {
34333       {
34334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34335       };
34336     } catch (Dali::DaliException e) {
34337       {
34338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34339       };
34340     } catch (...) {
34341       {
34342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34343       };
34344     }
34345   }
34346
34347   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34348   return jresult;
34349 }
34350
34351
34352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34353   void * jresult ;
34354   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34355   Dali::Vector3 result;
34356
34357   arg1 = (Dali::Actor *)jarg1;
34358   {
34359     try {
34360       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34361     } catch (std::out_of_range& e) {
34362       {
34363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34364       };
34365     } catch (std::exception& e) {
34366       {
34367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34368       };
34369     } catch (Dali::DaliException e) {
34370       {
34371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34372       };
34373     } catch (...) {
34374       {
34375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34376       };
34377     }
34378   }
34379
34380   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34381   return jresult;
34382 }
34383
34384
34385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34386   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34387   float arg2 ;
34388   float arg3 ;
34389
34390   arg1 = (Dali::Actor *)jarg1;
34391   arg2 = (float)jarg2;
34392   arg3 = (float)jarg3;
34393   {
34394     try {
34395       (arg1)->SetPosition(arg2,arg3);
34396     } catch (std::out_of_range& e) {
34397       {
34398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34399       };
34400     } catch (std::exception& e) {
34401       {
34402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34403       };
34404     } catch (Dali::DaliException e) {
34405       {
34406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34407       };
34408     } catch (...) {
34409       {
34410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34411       };
34412     }
34413   }
34414
34415 }
34416
34417
34418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34419   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34420   float arg2 ;
34421   float arg3 ;
34422   float arg4 ;
34423
34424   arg1 = (Dali::Actor *)jarg1;
34425   arg2 = (float)jarg2;
34426   arg3 = (float)jarg3;
34427   arg4 = (float)jarg4;
34428   {
34429     try {
34430       (arg1)->SetPosition(arg2,arg3,arg4);
34431     } catch (std::out_of_range& e) {
34432       {
34433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34434       };
34435     } catch (std::exception& e) {
34436       {
34437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34438       };
34439     } catch (Dali::DaliException e) {
34440       {
34441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34442       };
34443     } catch (...) {
34444       {
34445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34446       };
34447     }
34448   }
34449
34450 }
34451
34452
34453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34454   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34455   Dali::Vector3 *arg2 = 0 ;
34456
34457   arg1 = (Dali::Actor *)jarg1;
34458   arg2 = (Dali::Vector3 *)jarg2;
34459   if (!arg2) {
34460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34461     return ;
34462   }
34463   {
34464     try {
34465       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
34466     } catch (std::out_of_range& e) {
34467       {
34468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34469       };
34470     } catch (std::exception& e) {
34471       {
34472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34473       };
34474     } catch (Dali::DaliException e) {
34475       {
34476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34477       };
34478     } catch (...) {
34479       {
34480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34481       };
34482     }
34483   }
34484
34485 }
34486
34487
34488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34489   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34490   float arg2 ;
34491
34492   arg1 = (Dali::Actor *)jarg1;
34493   arg2 = (float)jarg2;
34494   {
34495     try {
34496       (arg1)->SetX(arg2);
34497     } catch (std::out_of_range& e) {
34498       {
34499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34500       };
34501     } catch (std::exception& e) {
34502       {
34503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34504       };
34505     } catch (Dali::DaliException e) {
34506       {
34507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34508       };
34509     } catch (...) {
34510       {
34511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34512       };
34513     }
34514   }
34515
34516 }
34517
34518
34519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34520   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34521   float arg2 ;
34522
34523   arg1 = (Dali::Actor *)jarg1;
34524   arg2 = (float)jarg2;
34525   {
34526     try {
34527       (arg1)->SetY(arg2);
34528     } catch (std::out_of_range& e) {
34529       {
34530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34531       };
34532     } catch (std::exception& e) {
34533       {
34534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34535       };
34536     } catch (Dali::DaliException e) {
34537       {
34538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34539       };
34540     } catch (...) {
34541       {
34542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34543       };
34544     }
34545   }
34546
34547 }
34548
34549
34550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
34551   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34552   float arg2 ;
34553
34554   arg1 = (Dali::Actor *)jarg1;
34555   arg2 = (float)jarg2;
34556   {
34557     try {
34558       (arg1)->SetZ(arg2);
34559     } catch (std::out_of_range& e) {
34560       {
34561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34562       };
34563     } catch (std::exception& e) {
34564       {
34565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34566       };
34567     } catch (Dali::DaliException e) {
34568       {
34569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34570       };
34571     } catch (...) {
34572       {
34573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34574       };
34575     }
34576   }
34577
34578 }
34579
34580
34581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
34582   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34583   Dali::Vector3 *arg2 = 0 ;
34584
34585   arg1 = (Dali::Actor *)jarg1;
34586   arg2 = (Dali::Vector3 *)jarg2;
34587   if (!arg2) {
34588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34589     return ;
34590   }
34591   {
34592     try {
34593       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
34594     } catch (std::out_of_range& e) {
34595       {
34596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34597       };
34598     } catch (std::exception& e) {
34599       {
34600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34601       };
34602     } catch (Dali::DaliException e) {
34603       {
34604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34605       };
34606     } catch (...) {
34607       {
34608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34609       };
34610     }
34611   }
34612
34613 }
34614
34615
34616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
34617   void * jresult ;
34618   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34619   Dali::Vector3 result;
34620
34621   arg1 = (Dali::Actor *)jarg1;
34622   {
34623     try {
34624       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
34625     } catch (std::out_of_range& e) {
34626       {
34627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34628       };
34629     } catch (std::exception& e) {
34630       {
34631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34632       };
34633     } catch (Dali::DaliException e) {
34634       {
34635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34636       };
34637     } catch (...) {
34638       {
34639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34640       };
34641     }
34642   }
34643
34644   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34645   return jresult;
34646 }
34647
34648
34649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
34650   void * jresult ;
34651   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34652   Dali::Vector3 result;
34653
34654   arg1 = (Dali::Actor *)jarg1;
34655   {
34656     try {
34657       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
34658     } catch (std::out_of_range& e) {
34659       {
34660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34661       };
34662     } catch (std::exception& e) {
34663       {
34664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34665       };
34666     } catch (Dali::DaliException e) {
34667       {
34668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34669       };
34670     } catch (...) {
34671       {
34672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34673       };
34674     }
34675   }
34676
34677   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34678   return jresult;
34679 }
34680
34681
34682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
34683   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34684   bool arg2 ;
34685
34686   arg1 = (Dali::Actor *)jarg1;
34687   arg2 = jarg2 ? true : false;
34688   {
34689     try {
34690       (arg1)->SetInheritPosition(arg2);
34691     } catch (std::out_of_range& e) {
34692       {
34693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34694       };
34695     } catch (std::exception& e) {
34696       {
34697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34698       };
34699     } catch (Dali::DaliException e) {
34700       {
34701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34702       };
34703     } catch (...) {
34704       {
34705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34706       };
34707     }
34708   }
34709
34710 }
34711
34712
34713 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetPositionInheritanceMode(void * jarg1) {
34714   int jresult ;
34715   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34716   Dali::PositionInheritanceMode result;
34717
34718   arg1 = (Dali::Actor *)jarg1;
34719   {
34720     try {
34721       result = (Dali::PositionInheritanceMode)((Dali::Actor const *)arg1)->GetPositionInheritanceMode();
34722     } catch (std::out_of_range& e) {
34723       {
34724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34725       };
34726     } catch (std::exception& e) {
34727       {
34728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34729       };
34730     } catch (Dali::DaliException e) {
34731       {
34732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34733       };
34734     } catch (...) {
34735       {
34736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34737       };
34738     }
34739   }
34740
34741   jresult = (int)result;
34742   return jresult;
34743 }
34744
34745
34746 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
34747   unsigned int jresult ;
34748   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34749   bool result;
34750
34751   arg1 = (Dali::Actor *)jarg1;
34752   {
34753     try {
34754       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
34755     } catch (std::out_of_range& e) {
34756       {
34757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34758       };
34759     } catch (std::exception& e) {
34760       {
34761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34762       };
34763     } catch (Dali::DaliException e) {
34764       {
34765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34766       };
34767     } catch (...) {
34768       {
34769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34770       };
34771     }
34772   }
34773
34774   jresult = result;
34775   return jresult;
34776 }
34777
34778
34779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34780   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34781   Dali::Degree *arg2 = 0 ;
34782   Dali::Vector3 *arg3 = 0 ;
34783
34784   arg1 = (Dali::Actor *)jarg1;
34785   arg2 = (Dali::Degree *)jarg2;
34786   if (!arg2) {
34787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34788     return ;
34789   }
34790   arg3 = (Dali::Vector3 *)jarg3;
34791   if (!arg3) {
34792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34793     return ;
34794   }
34795   {
34796     try {
34797       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
34798     } catch (std::out_of_range& e) {
34799       {
34800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34801       };
34802     } catch (std::exception& e) {
34803       {
34804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34805       };
34806     } catch (Dali::DaliException e) {
34807       {
34808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34809       };
34810     } catch (...) {
34811       {
34812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34813       };
34814     }
34815   }
34816
34817 }
34818
34819
34820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
34821   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34822   Dali::Radian *arg2 = 0 ;
34823   Dali::Vector3 *arg3 = 0 ;
34824
34825   arg1 = (Dali::Actor *)jarg1;
34826   arg2 = (Dali::Radian *)jarg2;
34827   if (!arg2) {
34828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
34829     return ;
34830   }
34831   arg3 = (Dali::Vector3 *)jarg3;
34832   if (!arg3) {
34833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34834     return ;
34835   }
34836   {
34837     try {
34838       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
34839     } catch (std::out_of_range& e) {
34840       {
34841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34842       };
34843     } catch (std::exception& e) {
34844       {
34845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34846       };
34847     } catch (Dali::DaliException e) {
34848       {
34849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34850       };
34851     } catch (...) {
34852       {
34853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34854       };
34855     }
34856   }
34857
34858 }
34859
34860
34861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
34862   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34863   Dali::Quaternion *arg2 = 0 ;
34864
34865   arg1 = (Dali::Actor *)jarg1;
34866   arg2 = (Dali::Quaternion *)jarg2;
34867   if (!arg2) {
34868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
34869     return ;
34870   }
34871   {
34872     try {
34873       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
34874     } catch (std::out_of_range& e) {
34875       {
34876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34877       };
34878     } catch (std::exception& e) {
34879       {
34880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34881       };
34882     } catch (Dali::DaliException e) {
34883       {
34884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34885       };
34886     } catch (...) {
34887       {
34888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34889       };
34890     }
34891   }
34892
34893 }
34894
34895
34896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34897   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34898   Dali::Degree *arg2 = 0 ;
34899   Dali::Vector3 *arg3 = 0 ;
34900
34901   arg1 = (Dali::Actor *)jarg1;
34902   arg2 = (Dali::Degree *)jarg2;
34903   if (!arg2) {
34904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34905     return ;
34906   }
34907   arg3 = (Dali::Vector3 *)jarg3;
34908   if (!arg3) {
34909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34910     return ;
34911   }
34912   {
34913     try {
34914       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
34915     } catch (std::out_of_range& e) {
34916       {
34917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34918       };
34919     } catch (std::exception& e) {
34920       {
34921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34922       };
34923     } catch (Dali::DaliException e) {
34924       {
34925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34926       };
34927     } catch (...) {
34928       {
34929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34930       };
34931     }
34932   }
34933
34934 }
34935
34936
34937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
34938   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34939   Dali::Radian *arg2 = 0 ;
34940   Dali::Vector3 *arg3 = 0 ;
34941
34942   arg1 = (Dali::Actor *)jarg1;
34943   arg2 = (Dali::Radian *)jarg2;
34944   if (!arg2) {
34945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
34946     return ;
34947   }
34948   arg3 = (Dali::Vector3 *)jarg3;
34949   if (!arg3) {
34950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34951     return ;
34952   }
34953   {
34954     try {
34955       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
34956     } catch (std::out_of_range& e) {
34957       {
34958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34959       };
34960     } catch (std::exception& e) {
34961       {
34962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34963       };
34964     } catch (Dali::DaliException e) {
34965       {
34966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34967       };
34968     } catch (...) {
34969       {
34970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34971       };
34972     }
34973   }
34974
34975 }
34976
34977
34978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
34979   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34980   Dali::Quaternion *arg2 = 0 ;
34981
34982   arg1 = (Dali::Actor *)jarg1;
34983   arg2 = (Dali::Quaternion *)jarg2;
34984   if (!arg2) {
34985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
34986     return ;
34987   }
34988   {
34989     try {
34990       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
34991     } catch (std::out_of_range& e) {
34992       {
34993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34994       };
34995     } catch (std::exception& e) {
34996       {
34997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34998       };
34999     } catch (Dali::DaliException e) {
35000       {
35001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35002       };
35003     } catch (...) {
35004       {
35005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35006       };
35007     }
35008   }
35009
35010 }
35011
35012
35013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
35014   void * jresult ;
35015   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35016   Dali::Quaternion result;
35017
35018   arg1 = (Dali::Actor *)jarg1;
35019   {
35020     try {
35021       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
35022     } catch (std::out_of_range& e) {
35023       {
35024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35025       };
35026     } catch (std::exception& e) {
35027       {
35028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35029       };
35030     } catch (Dali::DaliException e) {
35031       {
35032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35033       };
35034     } catch (...) {
35035       {
35036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35037       };
35038     }
35039   }
35040
35041   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35042   return jresult;
35043 }
35044
35045
35046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
35047   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35048   bool arg2 ;
35049
35050   arg1 = (Dali::Actor *)jarg1;
35051   arg2 = jarg2 ? true : false;
35052   {
35053     try {
35054       (arg1)->SetInheritOrientation(arg2);
35055     } catch (std::out_of_range& e) {
35056       {
35057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35058       };
35059     } catch (std::exception& e) {
35060       {
35061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35062       };
35063     } catch (Dali::DaliException e) {
35064       {
35065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35066       };
35067     } catch (...) {
35068       {
35069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35070       };
35071     }
35072   }
35073
35074 }
35075
35076
35077 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
35078   unsigned int jresult ;
35079   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35080   bool result;
35081
35082   arg1 = (Dali::Actor *)jarg1;
35083   {
35084     try {
35085       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
35086     } catch (std::out_of_range& e) {
35087       {
35088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35089       };
35090     } catch (std::exception& e) {
35091       {
35092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35093       };
35094     } catch (Dali::DaliException e) {
35095       {
35096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35097       };
35098     } catch (...) {
35099       {
35100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35101       };
35102     }
35103   }
35104
35105   jresult = result;
35106   return jresult;
35107 }
35108
35109
35110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35111   void * jresult ;
35112   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35113   Dali::Quaternion result;
35114
35115   arg1 = (Dali::Actor *)jarg1;
35116   {
35117     try {
35118       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
35119     } catch (std::out_of_range& e) {
35120       {
35121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35122       };
35123     } catch (std::exception& e) {
35124       {
35125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35126       };
35127     } catch (Dali::DaliException e) {
35128       {
35129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35130       };
35131     } catch (...) {
35132       {
35133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35134       };
35135     }
35136   }
35137
35138   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35139   return jresult;
35140 }
35141
35142
35143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35144   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35145   float arg2 ;
35146
35147   arg1 = (Dali::Actor *)jarg1;
35148   arg2 = (float)jarg2;
35149   {
35150     try {
35151       (arg1)->SetScale(arg2);
35152     } catch (std::out_of_range& e) {
35153       {
35154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35155       };
35156     } catch (std::exception& e) {
35157       {
35158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35159       };
35160     } catch (Dali::DaliException e) {
35161       {
35162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35163       };
35164     } catch (...) {
35165       {
35166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35167       };
35168     }
35169   }
35170
35171 }
35172
35173
35174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35175   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35176   float arg2 ;
35177   float arg3 ;
35178   float arg4 ;
35179
35180   arg1 = (Dali::Actor *)jarg1;
35181   arg2 = (float)jarg2;
35182   arg3 = (float)jarg3;
35183   arg4 = (float)jarg4;
35184   {
35185     try {
35186       (arg1)->SetScale(arg2,arg3,arg4);
35187     } catch (std::out_of_range& e) {
35188       {
35189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35190       };
35191     } catch (std::exception& e) {
35192       {
35193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35194       };
35195     } catch (Dali::DaliException e) {
35196       {
35197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35198       };
35199     } catch (...) {
35200       {
35201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35202       };
35203     }
35204   }
35205
35206 }
35207
35208
35209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35210   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35211   Dali::Vector3 *arg2 = 0 ;
35212
35213   arg1 = (Dali::Actor *)jarg1;
35214   arg2 = (Dali::Vector3 *)jarg2;
35215   if (!arg2) {
35216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35217     return ;
35218   }
35219   {
35220     try {
35221       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
35222     } catch (std::out_of_range& e) {
35223       {
35224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35225       };
35226     } catch (std::exception& e) {
35227       {
35228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35229       };
35230     } catch (Dali::DaliException e) {
35231       {
35232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35233       };
35234     } catch (...) {
35235       {
35236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35237       };
35238     }
35239   }
35240
35241 }
35242
35243
35244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35245   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35246   Dali::Vector3 *arg2 = 0 ;
35247
35248   arg1 = (Dali::Actor *)jarg1;
35249   arg2 = (Dali::Vector3 *)jarg2;
35250   if (!arg2) {
35251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35252     return ;
35253   }
35254   {
35255     try {
35256       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35257     } catch (std::out_of_range& e) {
35258       {
35259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35260       };
35261     } catch (std::exception& e) {
35262       {
35263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35264       };
35265     } catch (Dali::DaliException e) {
35266       {
35267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35268       };
35269     } catch (...) {
35270       {
35271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35272       };
35273     }
35274   }
35275
35276 }
35277
35278
35279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35280   void * jresult ;
35281   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35282   Dali::Vector3 result;
35283
35284   arg1 = (Dali::Actor *)jarg1;
35285   {
35286     try {
35287       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
35288     } catch (std::out_of_range& e) {
35289       {
35290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35291       };
35292     } catch (std::exception& e) {
35293       {
35294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35295       };
35296     } catch (Dali::DaliException e) {
35297       {
35298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35299       };
35300     } catch (...) {
35301       {
35302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35303       };
35304     }
35305   }
35306
35307   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35308   return jresult;
35309 }
35310
35311
35312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35313   void * jresult ;
35314   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35315   Dali::Vector3 result;
35316
35317   arg1 = (Dali::Actor *)jarg1;
35318   {
35319     try {
35320       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
35321     } catch (std::out_of_range& e) {
35322       {
35323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35324       };
35325     } catch (std::exception& e) {
35326       {
35327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35328       };
35329     } catch (Dali::DaliException e) {
35330       {
35331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35332       };
35333     } catch (...) {
35334       {
35335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35336       };
35337     }
35338   }
35339
35340   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35341   return jresult;
35342 }
35343
35344
35345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35346   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35347   bool arg2 ;
35348
35349   arg1 = (Dali::Actor *)jarg1;
35350   arg2 = jarg2 ? true : false;
35351   {
35352     try {
35353       (arg1)->SetInheritScale(arg2);
35354     } catch (std::out_of_range& e) {
35355       {
35356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35357       };
35358     } catch (std::exception& e) {
35359       {
35360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35361       };
35362     } catch (Dali::DaliException e) {
35363       {
35364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35365       };
35366     } catch (...) {
35367       {
35368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35369       };
35370     }
35371   }
35372
35373 }
35374
35375
35376 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35377   unsigned int jresult ;
35378   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35379   bool result;
35380
35381   arg1 = (Dali::Actor *)jarg1;
35382   {
35383     try {
35384       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
35385     } catch (std::out_of_range& e) {
35386       {
35387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35388       };
35389     } catch (std::exception& e) {
35390       {
35391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35392       };
35393     } catch (Dali::DaliException e) {
35394       {
35395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35396       };
35397     } catch (...) {
35398       {
35399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35400       };
35401     }
35402   }
35403
35404   jresult = result;
35405   return jresult;
35406 }
35407
35408
35409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35410   void * jresult ;
35411   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35412   Dali::Matrix result;
35413
35414   arg1 = (Dali::Actor *)jarg1;
35415   {
35416     try {
35417       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
35418     } catch (std::out_of_range& e) {
35419       {
35420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35421       };
35422     } catch (std::exception& e) {
35423       {
35424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35425       };
35426     } catch (Dali::DaliException e) {
35427       {
35428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35429       };
35430     } catch (...) {
35431       {
35432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35433       };
35434     }
35435   }
35436
35437   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35438   return jresult;
35439 }
35440
35441
35442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35443   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35444   bool arg2 ;
35445
35446   arg1 = (Dali::Actor *)jarg1;
35447   arg2 = jarg2 ? true : false;
35448   {
35449     try {
35450       (arg1)->SetVisible(arg2);
35451     } catch (std::out_of_range& e) {
35452       {
35453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35454       };
35455     } catch (std::exception& e) {
35456       {
35457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35458       };
35459     } catch (Dali::DaliException e) {
35460       {
35461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35462       };
35463     } catch (...) {
35464       {
35465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35466       };
35467     }
35468   }
35469
35470 }
35471
35472
35473 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35474   unsigned int jresult ;
35475   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35476   bool result;
35477
35478   arg1 = (Dali::Actor *)jarg1;
35479   {
35480     try {
35481       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
35482     } catch (std::out_of_range& e) {
35483       {
35484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35485       };
35486     } catch (std::exception& e) {
35487       {
35488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35489       };
35490     } catch (Dali::DaliException e) {
35491       {
35492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35493       };
35494     } catch (...) {
35495       {
35496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35497       };
35498     }
35499   }
35500
35501   jresult = result;
35502   return jresult;
35503 }
35504
35505
35506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35507   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35508   float arg2 ;
35509
35510   arg1 = (Dali::Actor *)jarg1;
35511   arg2 = (float)jarg2;
35512   {
35513     try {
35514       (arg1)->SetOpacity(arg2);
35515     } catch (std::out_of_range& e) {
35516       {
35517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35518       };
35519     } catch (std::exception& e) {
35520       {
35521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35522       };
35523     } catch (Dali::DaliException e) {
35524       {
35525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35526       };
35527     } catch (...) {
35528       {
35529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35530       };
35531     }
35532   }
35533
35534 }
35535
35536
35537 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35538   float jresult ;
35539   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35540   float result;
35541
35542   arg1 = (Dali::Actor *)jarg1;
35543   {
35544     try {
35545       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
35546     } catch (std::out_of_range& e) {
35547       {
35548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35549       };
35550     } catch (std::exception& e) {
35551       {
35552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35553       };
35554     } catch (Dali::DaliException e) {
35555       {
35556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35557       };
35558     } catch (...) {
35559       {
35560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35561       };
35562     }
35563   }
35564
35565   jresult = result;
35566   return jresult;
35567 }
35568
35569
35570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
35571   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35572   Dali::Vector4 *arg2 = 0 ;
35573
35574   arg1 = (Dali::Actor *)jarg1;
35575   arg2 = (Dali::Vector4 *)jarg2;
35576   if (!arg2) {
35577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35578     return ;
35579   }
35580   {
35581     try {
35582       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
35583     } catch (std::out_of_range& e) {
35584       {
35585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35586       };
35587     } catch (std::exception& e) {
35588       {
35589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35590       };
35591     } catch (Dali::DaliException e) {
35592       {
35593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35594       };
35595     } catch (...) {
35596       {
35597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35598       };
35599     }
35600   }
35601
35602 }
35603
35604
35605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
35606   void * jresult ;
35607   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35608   Dali::Vector4 result;
35609
35610   arg1 = (Dali::Actor *)jarg1;
35611   {
35612     try {
35613       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
35614     } catch (std::out_of_range& e) {
35615       {
35616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35617       };
35618     } catch (std::exception& e) {
35619       {
35620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35621       };
35622     } catch (Dali::DaliException e) {
35623       {
35624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35625       };
35626     } catch (...) {
35627       {
35628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35629       };
35630     }
35631   }
35632
35633   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35634   return jresult;
35635 }
35636
35637
35638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
35639   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35640   Dali::ColorMode arg2 ;
35641
35642   arg1 = (Dali::Actor *)jarg1;
35643   arg2 = (Dali::ColorMode)jarg2;
35644   {
35645     try {
35646       (arg1)->SetColorMode(arg2);
35647     } catch (std::out_of_range& e) {
35648       {
35649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35650       };
35651     } catch (std::exception& e) {
35652       {
35653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35654       };
35655     } catch (Dali::DaliException e) {
35656       {
35657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35658       };
35659     } catch (...) {
35660       {
35661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35662       };
35663     }
35664   }
35665
35666 }
35667
35668
35669 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
35670   int jresult ;
35671   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35672   Dali::ColorMode result;
35673
35674   arg1 = (Dali::Actor *)jarg1;
35675   {
35676     try {
35677       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
35678     } catch (std::out_of_range& e) {
35679       {
35680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35681       };
35682     } catch (std::exception& e) {
35683       {
35684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35685       };
35686     } catch (Dali::DaliException e) {
35687       {
35688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35689       };
35690     } catch (...) {
35691       {
35692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35693       };
35694     }
35695   }
35696
35697   jresult = (int)result;
35698   return jresult;
35699 }
35700
35701
35702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
35703   void * jresult ;
35704   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35705   Dali::Vector4 result;
35706
35707   arg1 = (Dali::Actor *)jarg1;
35708   {
35709     try {
35710       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
35711     } catch (std::out_of_range& e) {
35712       {
35713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35714       };
35715     } catch (std::exception& e) {
35716       {
35717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35718       };
35719     } catch (Dali::DaliException e) {
35720       {
35721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35722       };
35723     } catch (...) {
35724       {
35725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35726       };
35727     }
35728   }
35729
35730   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35731   return jresult;
35732 }
35733
35734
35735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
35736   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35737   Dali::DrawMode::Type arg2 ;
35738
35739   arg1 = (Dali::Actor *)jarg1;
35740   arg2 = (Dali::DrawMode::Type)jarg2;
35741   {
35742     try {
35743       (arg1)->SetDrawMode(arg2);
35744     } catch (std::out_of_range& e) {
35745       {
35746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35747       };
35748     } catch (std::exception& e) {
35749       {
35750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35751       };
35752     } catch (Dali::DaliException e) {
35753       {
35754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35755       };
35756     } catch (...) {
35757       {
35758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35759       };
35760     }
35761   }
35762
35763 }
35764
35765
35766 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
35767   int jresult ;
35768   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35769   Dali::DrawMode::Type result;
35770
35771   arg1 = (Dali::Actor *)jarg1;
35772   {
35773     try {
35774       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
35775     } catch (std::out_of_range& e) {
35776       {
35777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35778       };
35779     } catch (std::exception& e) {
35780       {
35781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35782       };
35783     } catch (Dali::DaliException e) {
35784       {
35785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35786       };
35787     } catch (...) {
35788       {
35789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35790       };
35791     }
35792   }
35793
35794   jresult = (int)result;
35795   return jresult;
35796 }
35797
35798
35799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
35800   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35801   bool arg2 ;
35802
35803   arg1 = (Dali::Actor *)jarg1;
35804   arg2 = jarg2 ? true : false;
35805   {
35806     try {
35807       (arg1)->SetSensitive(arg2);
35808     } catch (std::out_of_range& e) {
35809       {
35810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35811       };
35812     } catch (std::exception& e) {
35813       {
35814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35815       };
35816     } catch (Dali::DaliException e) {
35817       {
35818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35819       };
35820     } catch (...) {
35821       {
35822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35823       };
35824     }
35825   }
35826
35827 }
35828
35829
35830 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
35831   unsigned int jresult ;
35832   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35833   bool result;
35834
35835   arg1 = (Dali::Actor *)jarg1;
35836   {
35837     try {
35838       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
35839     } catch (std::out_of_range& e) {
35840       {
35841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35842       };
35843     } catch (std::exception& e) {
35844       {
35845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35846       };
35847     } catch (Dali::DaliException e) {
35848       {
35849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35850       };
35851     } catch (...) {
35852       {
35853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35854       };
35855     }
35856   }
35857
35858   jresult = result;
35859   return jresult;
35860 }
35861
35862
35863 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
35864   unsigned int jresult ;
35865   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35866   float *arg2 = 0 ;
35867   float *arg3 = 0 ;
35868   float arg4 ;
35869   float arg5 ;
35870   bool result;
35871
35872   arg1 = (Dali::Actor *)jarg1;
35873   arg2 = (float *)jarg2;
35874   arg3 = (float *)jarg3;
35875   arg4 = (float)jarg4;
35876   arg5 = (float)jarg5;
35877   {
35878     try {
35879       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
35880     } catch (std::out_of_range& e) {
35881       {
35882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35883       };
35884     } catch (std::exception& e) {
35885       {
35886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35887       };
35888     } catch (Dali::DaliException e) {
35889       {
35890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35891       };
35892     } catch (...) {
35893       {
35894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35895       };
35896     }
35897   }
35898
35899   jresult = result;
35900   return jresult;
35901 }
35902
35903
35904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
35905   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35906   bool arg2 ;
35907
35908   arg1 = (Dali::Actor *)jarg1;
35909   arg2 = jarg2 ? true : false;
35910   {
35911     try {
35912       (arg1)->SetLeaveRequired(arg2);
35913     } catch (std::out_of_range& e) {
35914       {
35915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35916       };
35917     } catch (std::exception& e) {
35918       {
35919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35920       };
35921     } catch (Dali::DaliException e) {
35922       {
35923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35924       };
35925     } catch (...) {
35926       {
35927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35928       };
35929     }
35930   }
35931
35932 }
35933
35934
35935 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
35936   unsigned int jresult ;
35937   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35938   bool result;
35939
35940   arg1 = (Dali::Actor *)jarg1;
35941   {
35942     try {
35943       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
35944     } catch (std::out_of_range& e) {
35945       {
35946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35947       };
35948     } catch (std::exception& e) {
35949       {
35950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35951       };
35952     } catch (Dali::DaliException e) {
35953       {
35954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35955       };
35956     } catch (...) {
35957       {
35958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35959       };
35960     }
35961   }
35962
35963   jresult = result;
35964   return jresult;
35965 }
35966
35967
35968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
35969   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35970   bool arg2 ;
35971
35972   arg1 = (Dali::Actor *)jarg1;
35973   arg2 = jarg2 ? true : false;
35974   {
35975     try {
35976       (arg1)->SetKeyboardFocusable(arg2);
35977     } catch (std::out_of_range& e) {
35978       {
35979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35980       };
35981     } catch (std::exception& e) {
35982       {
35983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35984       };
35985     } catch (Dali::DaliException e) {
35986       {
35987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35988       };
35989     } catch (...) {
35990       {
35991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35992       };
35993     }
35994   }
35995
35996 }
35997
35998
35999 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
36000   unsigned int jresult ;
36001   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36002   bool result;
36003
36004   arg1 = (Dali::Actor *)jarg1;
36005   {
36006     try {
36007       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
36008     } catch (std::out_of_range& e) {
36009       {
36010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36011       };
36012     } catch (std::exception& e) {
36013       {
36014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36015       };
36016     } catch (Dali::DaliException e) {
36017       {
36018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36019       };
36020     } catch (...) {
36021       {
36022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36023       };
36024     }
36025   }
36026
36027   jresult = result;
36028   return jresult;
36029 }
36030
36031
36032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36033   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36034   Dali::ResizePolicy::Type arg2 ;
36035   Dali::Dimension::Type arg3 ;
36036
36037   arg1 = (Dali::Actor *)jarg1;
36038   arg2 = (Dali::ResizePolicy::Type)jarg2;
36039   arg3 = (Dali::Dimension::Type)jarg3;
36040   {
36041     try {
36042       (arg1)->SetResizePolicy(arg2,arg3);
36043     } catch (std::out_of_range& e) {
36044       {
36045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36046       };
36047     } catch (std::exception& e) {
36048       {
36049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36050       };
36051     } catch (Dali::DaliException e) {
36052       {
36053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36054       };
36055     } catch (...) {
36056       {
36057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36058       };
36059     }
36060   }
36061
36062 }
36063
36064
36065 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
36066   int jresult ;
36067   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36068   Dali::Dimension::Type arg2 ;
36069   Dali::ResizePolicy::Type result;
36070
36071   arg1 = (Dali::Actor *)jarg1;
36072   arg2 = (Dali::Dimension::Type)jarg2;
36073   {
36074     try {
36075       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
36076     } catch (std::out_of_range& e) {
36077       {
36078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36079       };
36080     } catch (std::exception& e) {
36081       {
36082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36083       };
36084     } catch (Dali::DaliException e) {
36085       {
36086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36087       };
36088     } catch (...) {
36089       {
36090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36091       };
36092     }
36093   }
36094
36095   jresult = (int)result;
36096   return jresult;
36097 }
36098
36099
36100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36101   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36102   Dali::SizeScalePolicy::Type arg2 ;
36103
36104   arg1 = (Dali::Actor *)jarg1;
36105   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36106   {
36107     try {
36108       (arg1)->SetSizeScalePolicy(arg2);
36109     } catch (std::out_of_range& e) {
36110       {
36111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36112       };
36113     } catch (std::exception& e) {
36114       {
36115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36116       };
36117     } catch (Dali::DaliException e) {
36118       {
36119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36120       };
36121     } catch (...) {
36122       {
36123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36124       };
36125     }
36126   }
36127
36128 }
36129
36130
36131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36132   int jresult ;
36133   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36134   Dali::SizeScalePolicy::Type result;
36135
36136   arg1 = (Dali::Actor *)jarg1;
36137   {
36138     try {
36139       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
36140     } catch (std::out_of_range& e) {
36141       {
36142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36143       };
36144     } catch (std::exception& e) {
36145       {
36146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36147       };
36148     } catch (Dali::DaliException e) {
36149       {
36150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36151       };
36152     } catch (...) {
36153       {
36154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36155       };
36156     }
36157   }
36158
36159   jresult = (int)result;
36160   return jresult;
36161 }
36162
36163
36164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36165   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36166   Dali::Vector3 *arg2 = 0 ;
36167
36168   arg1 = (Dali::Actor *)jarg1;
36169   arg2 = (Dali::Vector3 *)jarg2;
36170   if (!arg2) {
36171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36172     return ;
36173   }
36174   {
36175     try {
36176       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
36177     } catch (std::out_of_range& e) {
36178       {
36179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36180       };
36181     } catch (std::exception& e) {
36182       {
36183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36184       };
36185     } catch (Dali::DaliException e) {
36186       {
36187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36188       };
36189     } catch (...) {
36190       {
36191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36192       };
36193     }
36194   }
36195
36196 }
36197
36198
36199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36200   void * jresult ;
36201   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36202   Dali::Vector3 result;
36203
36204   arg1 = (Dali::Actor *)jarg1;
36205   {
36206     try {
36207       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
36208     } catch (std::out_of_range& e) {
36209       {
36210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36211       };
36212     } catch (std::exception& e) {
36213       {
36214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36215       };
36216     } catch (Dali::DaliException e) {
36217       {
36218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36219       };
36220     } catch (...) {
36221       {
36222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36223       };
36224     }
36225   }
36226
36227   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36228   return jresult;
36229 }
36230
36231
36232 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36233   float jresult ;
36234   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36235   float arg2 ;
36236   float result;
36237
36238   arg1 = (Dali::Actor *)jarg1;
36239   arg2 = (float)jarg2;
36240   {
36241     try {
36242       result = (float)(arg1)->GetHeightForWidth(arg2);
36243     } catch (std::out_of_range& e) {
36244       {
36245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36246       };
36247     } catch (std::exception& e) {
36248       {
36249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36250       };
36251     } catch (Dali::DaliException e) {
36252       {
36253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36254       };
36255     } catch (...) {
36256       {
36257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36258       };
36259     }
36260   }
36261
36262   jresult = result;
36263   return jresult;
36264 }
36265
36266
36267 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36268   float jresult ;
36269   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36270   float arg2 ;
36271   float result;
36272
36273   arg1 = (Dali::Actor *)jarg1;
36274   arg2 = (float)jarg2;
36275   {
36276     try {
36277       result = (float)(arg1)->GetWidthForHeight(arg2);
36278     } catch (std::out_of_range& e) {
36279       {
36280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36281       };
36282     } catch (std::exception& e) {
36283       {
36284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36285       };
36286     } catch (Dali::DaliException e) {
36287       {
36288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36289       };
36290     } catch (...) {
36291       {
36292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36293       };
36294     }
36295   }
36296
36297   jresult = result;
36298   return jresult;
36299 }
36300
36301
36302 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36303   float jresult ;
36304   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36305   Dali::Dimension::Type arg2 ;
36306   float result;
36307
36308   arg1 = (Dali::Actor *)jarg1;
36309   arg2 = (Dali::Dimension::Type)jarg2;
36310   {
36311     try {
36312       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36313     } catch (std::out_of_range& e) {
36314       {
36315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36316       };
36317     } catch (std::exception& e) {
36318       {
36319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36320       };
36321     } catch (Dali::DaliException e) {
36322       {
36323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36324       };
36325     } catch (...) {
36326       {
36327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36328       };
36329     }
36330   }
36331
36332   jresult = result;
36333   return jresult;
36334 }
36335
36336
36337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36338   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36339   Dali::Padding *arg2 = 0 ;
36340
36341   arg1 = (Dali::Actor *)jarg1;
36342   arg2 = (Dali::Padding *)jarg2;
36343   if (!arg2) {
36344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36345     return ;
36346   }
36347   {
36348     try {
36349       (arg1)->SetPadding((Dali::Padding const &)*arg2);
36350     } catch (std::out_of_range& e) {
36351       {
36352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36353       };
36354     } catch (std::exception& e) {
36355       {
36356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36357       };
36358     } catch (Dali::DaliException e) {
36359       {
36360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36361       };
36362     } catch (...) {
36363       {
36364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36365       };
36366     }
36367   }
36368
36369 }
36370
36371
36372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36373   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36374   Dali::Padding *arg2 = 0 ;
36375
36376   arg1 = (Dali::Actor *)jarg1;
36377   arg2 = (Dali::Padding *)jarg2;
36378   if (!arg2) {
36379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36380     return ;
36381   }
36382   {
36383     try {
36384       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
36385     } catch (std::out_of_range& e) {
36386       {
36387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36388       };
36389     } catch (std::exception& e) {
36390       {
36391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36392       };
36393     } catch (Dali::DaliException e) {
36394       {
36395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36396       };
36397     } catch (...) {
36398       {
36399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36400       };
36401     }
36402   }
36403
36404 }
36405
36406
36407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36408   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36409   Dali::Vector2 *arg2 = 0 ;
36410
36411   arg1 = (Dali::Actor *)jarg1;
36412   arg2 = (Dali::Vector2 *)jarg2;
36413   if (!arg2) {
36414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36415     return ;
36416   }
36417   {
36418     try {
36419       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
36420     } catch (std::out_of_range& e) {
36421       {
36422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36423       };
36424     } catch (std::exception& e) {
36425       {
36426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36427       };
36428     } catch (Dali::DaliException e) {
36429       {
36430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36431       };
36432     } catch (...) {
36433       {
36434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36435       };
36436     }
36437   }
36438
36439 }
36440
36441
36442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36443   void * jresult ;
36444   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36445   Dali::Vector2 result;
36446
36447   arg1 = (Dali::Actor *)jarg1;
36448   {
36449     try {
36450       result = (arg1)->GetMinimumSize();
36451     } catch (std::out_of_range& e) {
36452       {
36453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36454       };
36455     } catch (std::exception& e) {
36456       {
36457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36458       };
36459     } catch (Dali::DaliException e) {
36460       {
36461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36462       };
36463     } catch (...) {
36464       {
36465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36466       };
36467     }
36468   }
36469
36470   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36471   return jresult;
36472 }
36473
36474
36475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36476   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36477   Dali::Vector2 *arg2 = 0 ;
36478
36479   arg1 = (Dali::Actor *)jarg1;
36480   arg2 = (Dali::Vector2 *)jarg2;
36481   if (!arg2) {
36482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36483     return ;
36484   }
36485   {
36486     try {
36487       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
36488     } catch (std::out_of_range& e) {
36489       {
36490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36491       };
36492     } catch (std::exception& e) {
36493       {
36494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36495       };
36496     } catch (Dali::DaliException e) {
36497       {
36498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36499       };
36500     } catch (...) {
36501       {
36502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36503       };
36504     }
36505   }
36506
36507 }
36508
36509
36510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36511   void * jresult ;
36512   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36513   Dali::Vector2 result;
36514
36515   arg1 = (Dali::Actor *)jarg1;
36516   {
36517     try {
36518       result = (arg1)->GetMaximumSize();
36519     } catch (std::out_of_range& e) {
36520       {
36521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36522       };
36523     } catch (std::exception& e) {
36524       {
36525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36526       };
36527     } catch (Dali::DaliException e) {
36528       {
36529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36530       };
36531     } catch (...) {
36532       {
36533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36534       };
36535     }
36536   }
36537
36538   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36539   return jresult;
36540 }
36541
36542
36543 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36544   int jresult ;
36545   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36546   int result;
36547
36548   arg1 = (Dali::Actor *)jarg1;
36549   {
36550     try {
36551       result = (int)(arg1)->GetHierarchyDepth();
36552     } catch (std::out_of_range& e) {
36553       {
36554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36555       };
36556     } catch (std::exception& e) {
36557       {
36558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36559       };
36560     } catch (Dali::DaliException e) {
36561       {
36562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36563       };
36564     } catch (...) {
36565       {
36566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36567       };
36568     }
36569   }
36570
36571   jresult = result;
36572   return jresult;
36573 }
36574
36575
36576 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
36577   unsigned int jresult ;
36578   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36579   Dali::Renderer *arg2 = 0 ;
36580   unsigned int result;
36581
36582   arg1 = (Dali::Actor *)jarg1;
36583   arg2 = (Dali::Renderer *)jarg2;
36584   if (!arg2) {
36585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36586     return 0;
36587   }
36588   {
36589     try {
36590       result = (unsigned int)(arg1)->AddRenderer(*arg2);
36591     } catch (std::out_of_range& e) {
36592       {
36593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36594       };
36595     } catch (std::exception& e) {
36596       {
36597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36598       };
36599     } catch (Dali::DaliException e) {
36600       {
36601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36602       };
36603     } catch (...) {
36604       {
36605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36606       };
36607     }
36608   }
36609
36610   jresult = result;
36611   return jresult;
36612 }
36613
36614
36615 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
36616   unsigned int jresult ;
36617   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36618   unsigned int result;
36619
36620   arg1 = (Dali::Actor *)jarg1;
36621   {
36622     try {
36623       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
36624     } catch (std::out_of_range& e) {
36625       {
36626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36627       };
36628     } catch (std::exception& e) {
36629       {
36630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36631       };
36632     } catch (Dali::DaliException e) {
36633       {
36634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36635       };
36636     } catch (...) {
36637       {
36638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36639       };
36640     }
36641   }
36642
36643   jresult = result;
36644   return jresult;
36645 }
36646
36647
36648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
36649   void * jresult ;
36650   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36651   unsigned int arg2 ;
36652   Dali::Renderer result;
36653
36654   arg1 = (Dali::Actor *)jarg1;
36655   arg2 = (unsigned int)jarg2;
36656   {
36657     try {
36658       result = (arg1)->GetRendererAt(arg2);
36659     } catch (std::out_of_range& e) {
36660       {
36661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36662       };
36663     } catch (std::exception& e) {
36664       {
36665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36666       };
36667     } catch (Dali::DaliException e) {
36668       {
36669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36670       };
36671     } catch (...) {
36672       {
36673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36674       };
36675     }
36676   }
36677
36678   jresult = new Dali::Renderer((const Dali::Renderer &)result);
36679   return jresult;
36680 }
36681
36682
36683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
36684   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36685   Dali::Renderer *arg2 = 0 ;
36686
36687   arg1 = (Dali::Actor *)jarg1;
36688   arg2 = (Dali::Renderer *)jarg2;
36689   if (!arg2) {
36690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36691     return ;
36692   }
36693   {
36694     try {
36695       (arg1)->RemoveRenderer(*arg2);
36696     } catch (std::out_of_range& e) {
36697       {
36698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36699       };
36700     } catch (std::exception& e) {
36701       {
36702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36703       };
36704     } catch (Dali::DaliException e) {
36705       {
36706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36707       };
36708     } catch (...) {
36709       {
36710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36711       };
36712     }
36713   }
36714
36715 }
36716
36717
36718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
36719   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36720   unsigned int arg2 ;
36721
36722   arg1 = (Dali::Actor *)jarg1;
36723   arg2 = (unsigned int)jarg2;
36724   {
36725     try {
36726       (arg1)->RemoveRenderer(arg2);
36727     } catch (std::out_of_range& e) {
36728       {
36729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36730       };
36731     } catch (std::exception& e) {
36732       {
36733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36734       };
36735     } catch (Dali::DaliException e) {
36736       {
36737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36738       };
36739     } catch (...) {
36740       {
36741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36742       };
36743     }
36744   }
36745
36746 }
36747
36748
36749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
36750   void * jresult ;
36751   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36752   Dali::Actor::TouchSignalType *result = 0 ;
36753
36754   arg1 = (Dali::Actor *)jarg1;
36755   {
36756     try {
36757       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
36758     } catch (std::out_of_range& e) {
36759       {
36760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36761       };
36762     } catch (std::exception& e) {
36763       {
36764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36765       };
36766     } catch (Dali::DaliException e) {
36767       {
36768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36769       };
36770     } catch (...) {
36771       {
36772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36773       };
36774     }
36775   }
36776
36777   jresult = (void *)result;
36778   return jresult;
36779 }
36780
36781
36782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
36783   void * jresult ;
36784   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36785   Dali::Actor::TouchDataSignalType *result = 0 ;
36786
36787   arg1 = (Dali::Actor *)jarg1;
36788   {
36789     try {
36790       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
36791     } catch (std::out_of_range& e) {
36792       {
36793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36794       };
36795     } catch (std::exception& e) {
36796       {
36797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36798       };
36799     } catch (Dali::DaliException e) {
36800       {
36801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36802       };
36803     } catch (...) {
36804       {
36805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36806       };
36807     }
36808   }
36809
36810   jresult = (void *)result;
36811   return jresult;
36812 }
36813
36814
36815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
36816   void * jresult ;
36817   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36818   Dali::Actor::HoverSignalType *result = 0 ;
36819
36820   arg1 = (Dali::Actor *)jarg1;
36821   {
36822     try {
36823       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
36824     } catch (std::out_of_range& e) {
36825       {
36826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36827       };
36828     } catch (std::exception& e) {
36829       {
36830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36831       };
36832     } catch (Dali::DaliException e) {
36833       {
36834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36835       };
36836     } catch (...) {
36837       {
36838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36839       };
36840     }
36841   }
36842
36843   jresult = (void *)result;
36844   return jresult;
36845 }
36846
36847
36848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
36849   void * jresult ;
36850   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36851   Dali::Actor::WheelEventSignalType *result = 0 ;
36852
36853   arg1 = (Dali::Actor *)jarg1;
36854   {
36855     try {
36856       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
36857     } catch (std::out_of_range& e) {
36858       {
36859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36860       };
36861     } catch (std::exception& e) {
36862       {
36863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36864       };
36865     } catch (Dali::DaliException e) {
36866       {
36867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36868       };
36869     } catch (...) {
36870       {
36871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36872       };
36873     }
36874   }
36875
36876   jresult = (void *)result;
36877   return jresult;
36878 }
36879
36880
36881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
36882   void * jresult ;
36883   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36884   Dali::Actor::OnStageSignalType *result = 0 ;
36885
36886   arg1 = (Dali::Actor *)jarg1;
36887   {
36888     try {
36889       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
36890     } catch (std::out_of_range& e) {
36891       {
36892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36893       };
36894     } catch (std::exception& e) {
36895       {
36896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36897       };
36898     } catch (Dali::DaliException e) {
36899       {
36900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36901       };
36902     } catch (...) {
36903       {
36904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36905       };
36906     }
36907   }
36908
36909   jresult = (void *)result;
36910   return jresult;
36911 }
36912
36913
36914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
36915   void * jresult ;
36916   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36917   Dali::Actor::OffStageSignalType *result = 0 ;
36918
36919   arg1 = (Dali::Actor *)jarg1;
36920   {
36921     try {
36922       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
36923     } catch (std::out_of_range& e) {
36924       {
36925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36926       };
36927     } catch (std::exception& e) {
36928       {
36929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36930       };
36931     } catch (Dali::DaliException e) {
36932       {
36933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36934       };
36935     } catch (...) {
36936       {
36937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36938       };
36939     }
36940   }
36941
36942   jresult = (void *)result;
36943   return jresult;
36944 }
36945
36946
36947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
36948   void * jresult ;
36949   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36950   Dali::Actor::OnRelayoutSignalType *result = 0 ;
36951
36952   arg1 = (Dali::Actor *)jarg1;
36953   {
36954     try {
36955       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
36956     } catch (std::out_of_range& e) {
36957       {
36958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36959       };
36960     } catch (std::exception& e) {
36961       {
36962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36963       };
36964     } catch (Dali::DaliException e) {
36965       {
36966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36967       };
36968     } catch (...) {
36969       {
36970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36971       };
36972     }
36973   }
36974
36975   jresult = (void *)result;
36976   return jresult;
36977 }
36978
36979
36980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
36981   Dali::Actor *arg1 = 0 ;
36982
36983   arg1 = (Dali::Actor *)jarg1;
36984   if (!arg1) {
36985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
36986     return ;
36987   }
36988   {
36989     try {
36990       Dali::UnparentAndReset(*arg1);
36991     } catch (std::out_of_range& e) {
36992       {
36993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36994       };
36995     } catch (std::exception& e) {
36996       {
36997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36998       };
36999     } catch (Dali::DaliException e) {
37000       {
37001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37002       };
37003     } catch (...) {
37004       {
37005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37006       };
37007     }
37008   }
37009
37010 }
37011
37012
37013 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
37014   int jresult ;
37015   int result;
37016
37017   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
37018   jresult = (int)result;
37019   return jresult;
37020 }
37021
37022
37023 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
37024   int jresult ;
37025   int result;
37026
37027   result = (int)Dali::Layer::Property::CLIPPING_BOX;
37028   jresult = (int)result;
37029   return jresult;
37030 }
37031
37032
37033 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
37034   int jresult ;
37035   int result;
37036
37037   result = (int)Dali::Layer::Property::BEHAVIOR;
37038   jresult = (int)result;
37039   return jresult;
37040 }
37041
37042
37043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
37044   void * jresult ;
37045   Dali::Layer::Property *result = 0 ;
37046
37047   {
37048     try {
37049       result = (Dali::Layer::Property *)new Dali::Layer::Property();
37050     } catch (std::out_of_range& e) {
37051       {
37052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37053       };
37054     } catch (std::exception& e) {
37055       {
37056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37057       };
37058     } catch (Dali::DaliException e) {
37059       {
37060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37061       };
37062     } catch (...) {
37063       {
37064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37065       };
37066     }
37067   }
37068
37069   jresult = (void *)result;
37070   return jresult;
37071 }
37072
37073
37074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
37075   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
37076
37077   arg1 = (Dali::Layer::Property *)jarg1;
37078   {
37079     try {
37080       delete arg1;
37081     } catch (std::out_of_range& e) {
37082       {
37083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37084       };
37085     } catch (std::exception& e) {
37086       {
37087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37088       };
37089     } catch (Dali::DaliException e) {
37090       {
37091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37092       };
37093     } catch (...) {
37094       {
37095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37096       };
37097     }
37098   }
37099
37100 }
37101
37102
37103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
37104   void * jresult ;
37105   Dali::Layer *result = 0 ;
37106
37107   {
37108     try {
37109       result = (Dali::Layer *)new Dali::Layer();
37110     } catch (std::out_of_range& e) {
37111       {
37112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37113       };
37114     } catch (std::exception& e) {
37115       {
37116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37117       };
37118     } catch (Dali::DaliException e) {
37119       {
37120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37121       };
37122     } catch (...) {
37123       {
37124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37125       };
37126     }
37127   }
37128
37129   jresult = (void *)result;
37130   return jresult;
37131 }
37132
37133
37134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37135   void * jresult ;
37136   Dali::Layer result;
37137
37138   {
37139     try {
37140       result = Dali::Layer::New();
37141     } catch (std::out_of_range& e) {
37142       {
37143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37144       };
37145     } catch (std::exception& e) {
37146       {
37147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37148       };
37149     } catch (Dali::DaliException e) {
37150       {
37151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37152       };
37153     } catch (...) {
37154       {
37155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37156       };
37157     }
37158   }
37159
37160   jresult = new Dali::Layer((const Dali::Layer &)result);
37161   return jresult;
37162 }
37163
37164
37165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
37166   void * jresult ;
37167   Dali::BaseHandle arg1 ;
37168   Dali::BaseHandle *argp1 ;
37169   Dali::Layer result;
37170
37171   argp1 = (Dali::BaseHandle *)jarg1;
37172   if (!argp1) {
37173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37174     return 0;
37175   }
37176   arg1 = *argp1;
37177   {
37178     try {
37179       result = Dali::Layer::DownCast(arg1);
37180     } catch (std::out_of_range& e) {
37181       {
37182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37183       };
37184     } catch (std::exception& e) {
37185       {
37186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37187       };
37188     } catch (Dali::DaliException e) {
37189       {
37190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37191       };
37192     } catch (...) {
37193       {
37194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37195       };
37196     }
37197   }
37198
37199   jresult = new Dali::Layer((const Dali::Layer &)result);
37200   return jresult;
37201 }
37202
37203
37204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
37205   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37206
37207   arg1 = (Dali::Layer *)jarg1;
37208   {
37209     try {
37210       delete arg1;
37211     } catch (std::out_of_range& e) {
37212       {
37213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37214       };
37215     } catch (std::exception& e) {
37216       {
37217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37218       };
37219     } catch (Dali::DaliException e) {
37220       {
37221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37222       };
37223     } catch (...) {
37224       {
37225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37226       };
37227     }
37228   }
37229
37230 }
37231
37232
37233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37234   void * jresult ;
37235   Dali::Layer *arg1 = 0 ;
37236   Dali::Layer *result = 0 ;
37237
37238   arg1 = (Dali::Layer *)jarg1;
37239   if (!arg1) {
37240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37241     return 0;
37242   }
37243   {
37244     try {
37245       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
37246     } catch (std::out_of_range& e) {
37247       {
37248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37249       };
37250     } catch (std::exception& e) {
37251       {
37252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37253       };
37254     } catch (Dali::DaliException e) {
37255       {
37256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37257       };
37258     } catch (...) {
37259       {
37260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37261       };
37262     }
37263   }
37264
37265   jresult = (void *)result;
37266   return jresult;
37267 }
37268
37269
37270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37271   void * jresult ;
37272   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37273   Dali::Layer *arg2 = 0 ;
37274   Dali::Layer *result = 0 ;
37275
37276   arg1 = (Dali::Layer *)jarg1;
37277   arg2 = (Dali::Layer *)jarg2;
37278   if (!arg2) {
37279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37280     return 0;
37281   }
37282   {
37283     try {
37284       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
37285     } catch (std::out_of_range& e) {
37286       {
37287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37288       };
37289     } catch (std::exception& e) {
37290       {
37291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37292       };
37293     } catch (Dali::DaliException e) {
37294       {
37295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37296       };
37297     } catch (...) {
37298       {
37299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37300       };
37301     }
37302   }
37303
37304   jresult = (void *)result;
37305   return jresult;
37306 }
37307
37308
37309 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37310   unsigned int jresult ;
37311   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37312   unsigned int result;
37313
37314   arg1 = (Dali::Layer *)jarg1;
37315   {
37316     try {
37317       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
37318     } catch (std::out_of_range& e) {
37319       {
37320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37321       };
37322     } catch (std::exception& e) {
37323       {
37324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37325       };
37326     } catch (Dali::DaliException e) {
37327       {
37328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37329       };
37330     } catch (...) {
37331       {
37332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37333       };
37334     }
37335   }
37336
37337   jresult = result;
37338   return jresult;
37339 }
37340
37341
37342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37343   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37344
37345   arg1 = (Dali::Layer *)jarg1;
37346   {
37347     try {
37348       (arg1)->Raise();
37349     } catch (std::out_of_range& e) {
37350       {
37351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37352       };
37353     } catch (std::exception& e) {
37354       {
37355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37356       };
37357     } catch (Dali::DaliException e) {
37358       {
37359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37360       };
37361     } catch (...) {
37362       {
37363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37364       };
37365     }
37366   }
37367
37368 }
37369
37370
37371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37372   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37373
37374   arg1 = (Dali::Layer *)jarg1;
37375   {
37376     try {
37377       (arg1)->Lower();
37378     } catch (std::out_of_range& e) {
37379       {
37380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37381       };
37382     } catch (std::exception& e) {
37383       {
37384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37385       };
37386     } catch (Dali::DaliException e) {
37387       {
37388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37389       };
37390     } catch (...) {
37391       {
37392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37393       };
37394     }
37395   }
37396
37397 }
37398
37399
37400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37401   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37402   Dali::Layer arg2 ;
37403   Dali::Layer *argp2 ;
37404
37405   arg1 = (Dali::Layer *)jarg1;
37406   argp2 = (Dali::Layer *)jarg2;
37407   if (!argp2) {
37408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37409     return ;
37410   }
37411   arg2 = *argp2;
37412   {
37413     try {
37414       (arg1)->RaiseAbove(arg2);
37415     } catch (std::out_of_range& e) {
37416       {
37417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37418       };
37419     } catch (std::exception& e) {
37420       {
37421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37422       };
37423     } catch (Dali::DaliException e) {
37424       {
37425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37426       };
37427     } catch (...) {
37428       {
37429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37430       };
37431     }
37432   }
37433
37434 }
37435
37436
37437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
37438   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37439   Dali::Layer arg2 ;
37440   Dali::Layer *argp2 ;
37441
37442   arg1 = (Dali::Layer *)jarg1;
37443   argp2 = (Dali::Layer *)jarg2;
37444   if (!argp2) {
37445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37446     return ;
37447   }
37448   arg2 = *argp2;
37449   {
37450     try {
37451       (arg1)->LowerBelow(arg2);
37452     } catch (std::out_of_range& e) {
37453       {
37454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37455       };
37456     } catch (std::exception& e) {
37457       {
37458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37459       };
37460     } catch (Dali::DaliException e) {
37461       {
37462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37463       };
37464     } catch (...) {
37465       {
37466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37467       };
37468     }
37469   }
37470
37471 }
37472
37473
37474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
37475   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37476
37477   arg1 = (Dali::Layer *)jarg1;
37478   {
37479     try {
37480       (arg1)->RaiseToTop();
37481     } catch (std::out_of_range& e) {
37482       {
37483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37484       };
37485     } catch (std::exception& e) {
37486       {
37487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37488       };
37489     } catch (Dali::DaliException e) {
37490       {
37491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37492       };
37493     } catch (...) {
37494       {
37495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37496       };
37497     }
37498   }
37499
37500 }
37501
37502
37503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
37504   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37505
37506   arg1 = (Dali::Layer *)jarg1;
37507   {
37508     try {
37509       (arg1)->LowerToBottom();
37510     } catch (std::out_of_range& e) {
37511       {
37512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37513       };
37514     } catch (std::exception& e) {
37515       {
37516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37517       };
37518     } catch (Dali::DaliException e) {
37519       {
37520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37521       };
37522     } catch (...) {
37523       {
37524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37525       };
37526     }
37527   }
37528
37529 }
37530
37531
37532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37533   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37534   Dali::Layer arg2 ;
37535   Dali::Layer *argp2 ;
37536
37537   arg1 = (Dali::Layer *)jarg1;
37538   argp2 = (Dali::Layer *)jarg2;
37539   if (!argp2) {
37540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37541     return ;
37542   }
37543   arg2 = *argp2;
37544   {
37545     try {
37546       (arg1)->MoveAbove(arg2);
37547     } catch (std::out_of_range& e) {
37548       {
37549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37550       };
37551     } catch (std::exception& e) {
37552       {
37553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37554       };
37555     } catch (Dali::DaliException e) {
37556       {
37557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37558       };
37559     } catch (...) {
37560       {
37561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37562       };
37563     }
37564   }
37565
37566 }
37567
37568
37569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
37570   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37571   Dali::Layer arg2 ;
37572   Dali::Layer *argp2 ;
37573
37574   arg1 = (Dali::Layer *)jarg1;
37575   argp2 = (Dali::Layer *)jarg2;
37576   if (!argp2) {
37577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37578     return ;
37579   }
37580   arg2 = *argp2;
37581   {
37582     try {
37583       (arg1)->MoveBelow(arg2);
37584     } catch (std::out_of_range& e) {
37585       {
37586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37587       };
37588     } catch (std::exception& e) {
37589       {
37590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37591       };
37592     } catch (Dali::DaliException e) {
37593       {
37594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37595       };
37596     } catch (...) {
37597       {
37598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37599       };
37600     }
37601   }
37602
37603 }
37604
37605
37606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
37607   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37608   Dali::Layer::Behavior arg2 ;
37609
37610   arg1 = (Dali::Layer *)jarg1;
37611   arg2 = (Dali::Layer::Behavior)jarg2;
37612   {
37613     try {
37614       (arg1)->SetBehavior(arg2);
37615     } catch (std::out_of_range& e) {
37616       {
37617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37618       };
37619     } catch (std::exception& e) {
37620       {
37621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37622       };
37623     } catch (Dali::DaliException e) {
37624       {
37625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37626       };
37627     } catch (...) {
37628       {
37629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37630       };
37631     }
37632   }
37633
37634 }
37635
37636
37637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
37638   int jresult ;
37639   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37640   Dali::Layer::Behavior result;
37641
37642   arg1 = (Dali::Layer *)jarg1;
37643   {
37644     try {
37645       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
37646     } catch (std::out_of_range& e) {
37647       {
37648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37649       };
37650     } catch (std::exception& e) {
37651       {
37652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37653       };
37654     } catch (Dali::DaliException e) {
37655       {
37656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37657       };
37658     } catch (...) {
37659       {
37660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37661       };
37662     }
37663   }
37664
37665   jresult = (int)result;
37666   return jresult;
37667 }
37668
37669
37670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
37671   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37672   bool arg2 ;
37673
37674   arg1 = (Dali::Layer *)jarg1;
37675   arg2 = jarg2 ? true : false;
37676   {
37677     try {
37678       (arg1)->SetClipping(arg2);
37679     } catch (std::out_of_range& e) {
37680       {
37681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37682       };
37683     } catch (std::exception& e) {
37684       {
37685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37686       };
37687     } catch (Dali::DaliException e) {
37688       {
37689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37690       };
37691     } catch (...) {
37692       {
37693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37694       };
37695     }
37696   }
37697
37698 }
37699
37700
37701 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
37702   unsigned int jresult ;
37703   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37704   bool result;
37705
37706   arg1 = (Dali::Layer *)jarg1;
37707   {
37708     try {
37709       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
37710     } catch (std::out_of_range& e) {
37711       {
37712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37713       };
37714     } catch (std::exception& e) {
37715       {
37716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37717       };
37718     } catch (Dali::DaliException e) {
37719       {
37720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37721       };
37722     } catch (...) {
37723       {
37724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37725       };
37726     }
37727   }
37728
37729   jresult = result;
37730   return jresult;
37731 }
37732
37733
37734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
37735   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37736   int arg2 ;
37737   int arg3 ;
37738   int arg4 ;
37739   int arg5 ;
37740
37741   arg1 = (Dali::Layer *)jarg1;
37742   arg2 = (int)jarg2;
37743   arg3 = (int)jarg3;
37744   arg4 = (int)jarg4;
37745   arg5 = (int)jarg5;
37746   {
37747     try {
37748       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
37749     } catch (std::out_of_range& e) {
37750       {
37751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37752       };
37753     } catch (std::exception& e) {
37754       {
37755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37756       };
37757     } catch (Dali::DaliException e) {
37758       {
37759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37760       };
37761     } catch (...) {
37762       {
37763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37764       };
37765     }
37766   }
37767
37768 }
37769
37770
37771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
37772   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37773   Dali::ClippingBox arg2 ;
37774   Dali::ClippingBox *argp2 ;
37775
37776   arg1 = (Dali::Layer *)jarg1;
37777   argp2 = (Dali::ClippingBox *)jarg2;
37778   if (!argp2) {
37779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
37780     return ;
37781   }
37782   arg2 = *argp2;
37783   {
37784     try {
37785       (arg1)->SetClippingBox(arg2);
37786     } catch (std::out_of_range& e) {
37787       {
37788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37789       };
37790     } catch (std::exception& e) {
37791       {
37792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37793       };
37794     } catch (Dali::DaliException e) {
37795       {
37796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37797       };
37798     } catch (...) {
37799       {
37800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37801       };
37802     }
37803   }
37804
37805 }
37806
37807
37808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
37809   void * jresult ;
37810   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37811   Dali::ClippingBox result;
37812
37813   arg1 = (Dali::Layer *)jarg1;
37814   {
37815     try {
37816       result = ((Dali::Layer const *)arg1)->GetClippingBox();
37817     } catch (std::out_of_range& e) {
37818       {
37819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37820       };
37821     } catch (std::exception& e) {
37822       {
37823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37824       };
37825     } catch (Dali::DaliException e) {
37826       {
37827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37828       };
37829     } catch (...) {
37830       {
37831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37832       };
37833     }
37834   }
37835
37836   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
37837   return jresult;
37838 }
37839
37840
37841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
37842   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37843   bool arg2 ;
37844
37845   arg1 = (Dali::Layer *)jarg1;
37846   arg2 = jarg2 ? true : false;
37847   {
37848     try {
37849       (arg1)->SetDepthTestDisabled(arg2);
37850     } catch (std::out_of_range& e) {
37851       {
37852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37853       };
37854     } catch (std::exception& e) {
37855       {
37856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37857       };
37858     } catch (Dali::DaliException e) {
37859       {
37860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37861       };
37862     } catch (...) {
37863       {
37864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37865       };
37866     }
37867   }
37868
37869 }
37870
37871
37872 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
37873   unsigned int jresult ;
37874   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37875   bool result;
37876
37877   arg1 = (Dali::Layer *)jarg1;
37878   {
37879     try {
37880       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
37881     } catch (std::out_of_range& e) {
37882       {
37883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37884       };
37885     } catch (std::exception& e) {
37886       {
37887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37888       };
37889     } catch (Dali::DaliException e) {
37890       {
37891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37892       };
37893     } catch (...) {
37894       {
37895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37896       };
37897     }
37898   }
37899
37900   jresult = result;
37901   return jresult;
37902 }
37903
37904
37905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
37906   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37907   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
37908
37909   arg1 = (Dali::Layer *)jarg1;
37910   arg2 = (Dali::Layer::SortFunctionType)jarg2;
37911   {
37912     try {
37913       (arg1)->SetSortFunction(arg2);
37914     } catch (std::out_of_range& e) {
37915       {
37916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37917       };
37918     } catch (std::exception& e) {
37919       {
37920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37921       };
37922     } catch (Dali::DaliException e) {
37923       {
37924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37925       };
37926     } catch (...) {
37927       {
37928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37929       };
37930     }
37931   }
37932
37933 }
37934
37935
37936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
37937   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37938   bool arg2 ;
37939
37940   arg1 = (Dali::Layer *)jarg1;
37941   arg2 = jarg2 ? true : false;
37942   {
37943     try {
37944       (arg1)->SetTouchConsumed(arg2);
37945     } catch (std::out_of_range& e) {
37946       {
37947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37948       };
37949     } catch (std::exception& e) {
37950       {
37951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37952       };
37953     } catch (Dali::DaliException e) {
37954       {
37955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37956       };
37957     } catch (...) {
37958       {
37959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37960       };
37961     }
37962   }
37963
37964 }
37965
37966
37967 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
37968   unsigned int jresult ;
37969   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37970   bool result;
37971
37972   arg1 = (Dali::Layer *)jarg1;
37973   {
37974     try {
37975       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
37976     } catch (std::out_of_range& e) {
37977       {
37978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37979       };
37980     } catch (std::exception& e) {
37981       {
37982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37983       };
37984     } catch (Dali::DaliException e) {
37985       {
37986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37987       };
37988     } catch (...) {
37989       {
37990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37991       };
37992     }
37993   }
37994
37995   jresult = result;
37996   return jresult;
37997 }
37998
37999
38000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
38001   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38002   bool arg2 ;
38003
38004   arg1 = (Dali::Layer *)jarg1;
38005   arg2 = jarg2 ? true : false;
38006   {
38007     try {
38008       (arg1)->SetHoverConsumed(arg2);
38009     } catch (std::out_of_range& e) {
38010       {
38011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38012       };
38013     } catch (std::exception& e) {
38014       {
38015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38016       };
38017     } catch (Dali::DaliException e) {
38018       {
38019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38020       };
38021     } catch (...) {
38022       {
38023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38024       };
38025     }
38026   }
38027
38028 }
38029
38030
38031 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
38032   unsigned int jresult ;
38033   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38034   bool result;
38035
38036   arg1 = (Dali::Layer *)jarg1;
38037   {
38038     try {
38039       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
38040     } catch (std::out_of_range& e) {
38041       {
38042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38043       };
38044     } catch (std::exception& e) {
38045       {
38046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38047       };
38048     } catch (Dali::DaliException e) {
38049       {
38050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38051       };
38052     } catch (...) {
38053       {
38054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38055       };
38056     }
38057   }
38058
38059   jresult = result;
38060   return jresult;
38061 }
38062
38063
38064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
38065   void * jresult ;
38066   Dali::Vector4 *result = 0 ;
38067
38068   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
38069   jresult = (void *)result;
38070   return jresult;
38071 }
38072
38073
38074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
38075   void * jresult ;
38076   Dali::Vector4 *result = 0 ;
38077
38078   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
38079   jresult = (void *)result;
38080   return jresult;
38081 }
38082
38083
38084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
38085   void * jresult ;
38086   Dali::Stage *result = 0 ;
38087
38088   {
38089     try {
38090       result = (Dali::Stage *)new Dali::Stage();
38091     } catch (std::out_of_range& e) {
38092       {
38093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38094       };
38095     } catch (std::exception& e) {
38096       {
38097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38098       };
38099     } catch (Dali::DaliException e) {
38100       {
38101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38102       };
38103     } catch (...) {
38104       {
38105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38106       };
38107     }
38108   }
38109
38110   jresult = (void *)result;
38111   return jresult;
38112 }
38113
38114
38115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
38116   void * jresult ;
38117   Dali::Stage result;
38118
38119   {
38120     try {
38121       result = Dali::Stage::GetCurrent();
38122     } catch (std::out_of_range& e) {
38123       {
38124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38125       };
38126     } catch (std::exception& e) {
38127       {
38128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38129       };
38130     } catch (Dali::DaliException e) {
38131       {
38132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38133       };
38134     } catch (...) {
38135       {
38136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38137       };
38138     }
38139   }
38140
38141   jresult = new Dali::Stage((const Dali::Stage &)result);
38142   return jresult;
38143 }
38144
38145
38146 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
38147   unsigned int jresult ;
38148   bool result;
38149
38150   {
38151     try {
38152       result = (bool)Dali::Stage::IsInstalled();
38153     } catch (std::out_of_range& e) {
38154       {
38155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38156       };
38157     } catch (std::exception& e) {
38158       {
38159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38160       };
38161     } catch (Dali::DaliException e) {
38162       {
38163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38164       };
38165     } catch (...) {
38166       {
38167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38168       };
38169     }
38170   }
38171
38172   jresult = result;
38173   return jresult;
38174 }
38175
38176
38177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
38178   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38179
38180   arg1 = (Dali::Stage *)jarg1;
38181   {
38182     try {
38183       delete arg1;
38184     } catch (std::out_of_range& e) {
38185       {
38186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38187       };
38188     } catch (std::exception& e) {
38189       {
38190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38191       };
38192     } catch (Dali::DaliException e) {
38193       {
38194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38195       };
38196     } catch (...) {
38197       {
38198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38199       };
38200     }
38201   }
38202
38203 }
38204
38205
38206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
38207   void * jresult ;
38208   Dali::Stage *arg1 = 0 ;
38209   Dali::Stage *result = 0 ;
38210
38211   arg1 = (Dali::Stage *)jarg1;
38212   if (!arg1) {
38213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38214     return 0;
38215   }
38216   {
38217     try {
38218       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
38219     } catch (std::out_of_range& e) {
38220       {
38221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38222       };
38223     } catch (std::exception& e) {
38224       {
38225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38226       };
38227     } catch (Dali::DaliException e) {
38228       {
38229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38230       };
38231     } catch (...) {
38232       {
38233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38234       };
38235     }
38236   }
38237
38238   jresult = (void *)result;
38239   return jresult;
38240 }
38241
38242
38243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
38244   void * jresult ;
38245   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38246   Dali::Stage *arg2 = 0 ;
38247   Dali::Stage *result = 0 ;
38248
38249   arg1 = (Dali::Stage *)jarg1;
38250   arg2 = (Dali::Stage *)jarg2;
38251   if (!arg2) {
38252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38253     return 0;
38254   }
38255   {
38256     try {
38257       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
38258     } catch (std::out_of_range& e) {
38259       {
38260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38261       };
38262     } catch (std::exception& e) {
38263       {
38264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38265       };
38266     } catch (Dali::DaliException e) {
38267       {
38268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38269       };
38270     } catch (...) {
38271       {
38272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38273       };
38274     }
38275   }
38276
38277   jresult = (void *)result;
38278   return jresult;
38279 }
38280
38281
38282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
38283   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38284   Dali::Actor *arg2 = 0 ;
38285
38286   arg1 = (Dali::Stage *)jarg1;
38287   arg2 = (Dali::Actor *)jarg2;
38288   if (!arg2) {
38289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38290     return ;
38291   }
38292   {
38293     try {
38294       (arg1)->Add(*arg2);
38295     } catch (std::out_of_range& e) {
38296       {
38297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38298       };
38299     } catch (std::exception& e) {
38300       {
38301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38302       };
38303     } catch (Dali::DaliException e) {
38304       {
38305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38306       };
38307     } catch (...) {
38308       {
38309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38310       };
38311     }
38312   }
38313
38314 }
38315
38316
38317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
38318   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38319   Dali::Actor *arg2 = 0 ;
38320
38321   arg1 = (Dali::Stage *)jarg1;
38322   arg2 = (Dali::Actor *)jarg2;
38323   if (!arg2) {
38324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38325     return ;
38326   }
38327   {
38328     try {
38329       (arg1)->Remove(*arg2);
38330     } catch (std::out_of_range& e) {
38331       {
38332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38333       };
38334     } catch (std::exception& e) {
38335       {
38336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38337       };
38338     } catch (Dali::DaliException e) {
38339       {
38340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38341       };
38342     } catch (...) {
38343       {
38344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38345       };
38346     }
38347   }
38348
38349 }
38350
38351
38352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
38353   void * jresult ;
38354   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38355   Dali::Vector2 result;
38356
38357   arg1 = (Dali::Stage *)jarg1;
38358   {
38359     try {
38360       result = ((Dali::Stage const *)arg1)->GetSize();
38361     } catch (std::out_of_range& e) {
38362       {
38363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38364       };
38365     } catch (std::exception& e) {
38366       {
38367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38368       };
38369     } catch (Dali::DaliException e) {
38370       {
38371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38372       };
38373     } catch (...) {
38374       {
38375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38376       };
38377     }
38378   }
38379
38380   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38381   return jresult;
38382 }
38383
38384
38385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
38386   void * jresult ;
38387   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38388   Dali::RenderTaskList result;
38389
38390   arg1 = (Dali::Stage *)jarg1;
38391   {
38392     try {
38393       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
38394     } catch (std::out_of_range& e) {
38395       {
38396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38397       };
38398     } catch (std::exception& e) {
38399       {
38400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38401       };
38402     } catch (Dali::DaliException e) {
38403       {
38404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38405       };
38406     } catch (...) {
38407       {
38408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38409       };
38410     }
38411   }
38412
38413   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
38414   return jresult;
38415 }
38416
38417
38418 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
38419   unsigned int jresult ;
38420   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38421   unsigned int result;
38422
38423   arg1 = (Dali::Stage *)jarg1;
38424   {
38425     try {
38426       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
38427     } catch (std::out_of_range& e) {
38428       {
38429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38430       };
38431     } catch (std::exception& e) {
38432       {
38433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38434       };
38435     } catch (Dali::DaliException e) {
38436       {
38437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38438       };
38439     } catch (...) {
38440       {
38441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38442       };
38443     }
38444   }
38445
38446   jresult = result;
38447   return jresult;
38448 }
38449
38450
38451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
38452   void * jresult ;
38453   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38454   unsigned int arg2 ;
38455   Dali::Layer result;
38456
38457   arg1 = (Dali::Stage *)jarg1;
38458   arg2 = (unsigned int)jarg2;
38459   {
38460     try {
38461       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
38462     } catch (std::out_of_range& e) {
38463       {
38464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38465       };
38466     } catch (std::exception& e) {
38467       {
38468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38469       };
38470     } catch (Dali::DaliException e) {
38471       {
38472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38473       };
38474     } catch (...) {
38475       {
38476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38477       };
38478     }
38479   }
38480
38481   jresult = new Dali::Layer((const Dali::Layer &)result);
38482   return jresult;
38483 }
38484
38485
38486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
38487   void * jresult ;
38488   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38489   Dali::Layer result;
38490
38491   arg1 = (Dali::Stage *)jarg1;
38492   {
38493     try {
38494       result = ((Dali::Stage const *)arg1)->GetRootLayer();
38495     } catch (std::out_of_range& e) {
38496       {
38497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38498       };
38499     } catch (std::exception& e) {
38500       {
38501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38502       };
38503     } catch (Dali::DaliException e) {
38504       {
38505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38506       };
38507     } catch (...) {
38508       {
38509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38510       };
38511     }
38512   }
38513
38514   jresult = new Dali::Layer((const Dali::Layer &)result);
38515   return jresult;
38516 }
38517
38518
38519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
38520   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38521   Dali::Vector4 arg2 ;
38522   Dali::Vector4 *argp2 ;
38523
38524   arg1 = (Dali::Stage *)jarg1;
38525   argp2 = (Dali::Vector4 *)jarg2;
38526   if (!argp2) {
38527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
38528     return ;
38529   }
38530   arg2 = *argp2;
38531   {
38532     try {
38533       (arg1)->SetBackgroundColor(arg2);
38534     } catch (std::out_of_range& e) {
38535       {
38536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38537       };
38538     } catch (std::exception& e) {
38539       {
38540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38541       };
38542     } catch (Dali::DaliException e) {
38543       {
38544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38545       };
38546     } catch (...) {
38547       {
38548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38549       };
38550     }
38551   }
38552
38553 }
38554
38555
38556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
38557   void * jresult ;
38558   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38559   Dali::Vector4 result;
38560
38561   arg1 = (Dali::Stage *)jarg1;
38562   {
38563     try {
38564       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
38565     } catch (std::out_of_range& e) {
38566       {
38567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38568       };
38569     } catch (std::exception& e) {
38570       {
38571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38572       };
38573     } catch (Dali::DaliException e) {
38574       {
38575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38576       };
38577     } catch (...) {
38578       {
38579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38580       };
38581     }
38582   }
38583
38584   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
38585   return jresult;
38586 }
38587
38588
38589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
38590   void * jresult ;
38591   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38592   Dali::Vector2 result;
38593
38594   arg1 = (Dali::Stage *)jarg1;
38595   {
38596     try {
38597       result = ((Dali::Stage const *)arg1)->GetDpi();
38598     } catch (std::out_of_range& e) {
38599       {
38600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38601       };
38602     } catch (std::exception& e) {
38603       {
38604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38605       };
38606     } catch (Dali::DaliException e) {
38607       {
38608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38609       };
38610     } catch (...) {
38611       {
38612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38613       };
38614     }
38615   }
38616
38617   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38618   return jresult;
38619 }
38620
38621
38622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
38623   void * jresult ;
38624   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38625   Dali::ObjectRegistry result;
38626
38627   arg1 = (Dali::Stage *)jarg1;
38628   {
38629     try {
38630       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
38631     } catch (std::out_of_range& e) {
38632       {
38633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38634       };
38635     } catch (std::exception& e) {
38636       {
38637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38638       };
38639     } catch (Dali::DaliException e) {
38640       {
38641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38642       };
38643     } catch (...) {
38644       {
38645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38646       };
38647     }
38648   }
38649
38650   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
38651   return jresult;
38652 }
38653
38654
38655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38656   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38657   float arg2 ;
38658
38659   arg1 = (Dali::Stage *)jarg1;
38660   arg2 = (float)jarg2;
38661   {
38662     try {
38663       (arg1)->KeepRendering(arg2);
38664     } catch (std::out_of_range& e) {
38665       {
38666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38667       };
38668     } catch (std::exception& e) {
38669       {
38670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38671       };
38672     } catch (Dali::DaliException e) {
38673       {
38674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38675       };
38676     } catch (...) {
38677       {
38678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38679       };
38680     }
38681   }
38682
38683 }
38684
38685
38686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38687   void * jresult ;
38688   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38689   Dali::Stage::KeyEventSignalType *result = 0 ;
38690
38691   arg1 = (Dali::Stage *)jarg1;
38692   {
38693     try {
38694       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38695     } catch (std::out_of_range& e) {
38696       {
38697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38698       };
38699     } catch (std::exception& e) {
38700       {
38701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38702       };
38703     } catch (Dali::DaliException e) {
38704       {
38705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38706       };
38707     } catch (...) {
38708       {
38709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38710       };
38711     }
38712   }
38713
38714   jresult = (void *)result;
38715   return jresult;
38716 }
38717
38718
38719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
38720   void * jresult ;
38721   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38722   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
38723
38724   arg1 = (Dali::Stage *)jarg1;
38725   {
38726     try {
38727       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
38728     } catch (std::out_of_range& e) {
38729       {
38730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38731       };
38732     } catch (std::exception& e) {
38733       {
38734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38735       };
38736     } catch (Dali::DaliException e) {
38737       {
38738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38739       };
38740     } catch (...) {
38741       {
38742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38743       };
38744     }
38745   }
38746
38747   jresult = (void *)result;
38748   return jresult;
38749 }
38750
38751
38752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
38753   void * jresult ;
38754   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38755   Dali::Stage::TouchSignalType *result = 0 ;
38756
38757   arg1 = (Dali::Stage *)jarg1;
38758   {
38759     try {
38760       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
38761     } catch (std::out_of_range& e) {
38762       {
38763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38764       };
38765     } catch (std::exception& e) {
38766       {
38767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38768       };
38769     } catch (Dali::DaliException e) {
38770       {
38771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38772       };
38773     } catch (...) {
38774       {
38775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38776       };
38777     }
38778   }
38779
38780   jresult = (void *)result;
38781   return jresult;
38782 }
38783
38784
38785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
38786   void * jresult ;
38787   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38788   Dali::Stage::WheelEventSignalType *result = 0 ;
38789
38790   arg1 = (Dali::Stage *)jarg1;
38791   {
38792     try {
38793       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
38794     } catch (std::out_of_range& e) {
38795       {
38796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38797       };
38798     } catch (std::exception& e) {
38799       {
38800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38801       };
38802     } catch (Dali::DaliException e) {
38803       {
38804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38805       };
38806     } catch (...) {
38807       {
38808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38809       };
38810     }
38811   }
38812
38813   jresult = (void *)result;
38814   return jresult;
38815 }
38816
38817
38818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
38819   void * jresult ;
38820   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38821   Dali::Stage::ContextStatusSignal *result = 0 ;
38822
38823   arg1 = (Dali::Stage *)jarg1;
38824   {
38825     try {
38826       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
38827     } catch (std::out_of_range& e) {
38828       {
38829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38830       };
38831     } catch (std::exception& e) {
38832       {
38833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38834       };
38835     } catch (Dali::DaliException e) {
38836       {
38837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38838       };
38839     } catch (...) {
38840       {
38841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38842       };
38843     }
38844   }
38845
38846   jresult = (void *)result;
38847   return jresult;
38848 }
38849
38850
38851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
38852   void * jresult ;
38853   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38854   Dali::Stage::ContextStatusSignal *result = 0 ;
38855
38856   arg1 = (Dali::Stage *)jarg1;
38857   {
38858     try {
38859       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
38860     } catch (std::out_of_range& e) {
38861       {
38862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38863       };
38864     } catch (std::exception& e) {
38865       {
38866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38867       };
38868     } catch (Dali::DaliException e) {
38869       {
38870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38871       };
38872     } catch (...) {
38873       {
38874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38875       };
38876     }
38877   }
38878
38879   jresult = (void *)result;
38880   return jresult;
38881 }
38882
38883
38884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
38885   void * jresult ;
38886   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38887   Dali::Stage::SceneCreatedSignalType *result = 0 ;
38888
38889   arg1 = (Dali::Stage *)jarg1;
38890   {
38891     try {
38892       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
38893     } catch (std::out_of_range& e) {
38894       {
38895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38896       };
38897     } catch (std::exception& e) {
38898       {
38899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38900       };
38901     } catch (Dali::DaliException e) {
38902       {
38903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38904       };
38905     } catch (...) {
38906       {
38907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38908       };
38909     }
38910   }
38911
38912   jresult = (void *)result;
38913   return jresult;
38914 }
38915
38916
38917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
38918   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
38919
38920   arg1 = (Dali::RelayoutContainer *)jarg1;
38921   {
38922     try {
38923       delete arg1;
38924     } catch (std::out_of_range& e) {
38925       {
38926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38927       };
38928     } catch (std::exception& e) {
38929       {
38930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38931       };
38932     } catch (Dali::DaliException e) {
38933       {
38934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38935       };
38936     } catch (...) {
38937       {
38938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38939       };
38940     }
38941   }
38942
38943 }
38944
38945
38946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
38947   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
38948   Dali::Actor *arg2 = 0 ;
38949   Dali::Vector2 *arg3 = 0 ;
38950
38951   arg1 = (Dali::RelayoutContainer *)jarg1;
38952   arg2 = (Dali::Actor *)jarg2;
38953   if (!arg2) {
38954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
38955     return ;
38956   }
38957   arg3 = (Dali::Vector2 *)jarg3;
38958   if (!arg3) {
38959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38960     return ;
38961   }
38962   {
38963     try {
38964       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
38965     } catch (std::out_of_range& e) {
38966       {
38967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38968       };
38969     } catch (std::exception& e) {
38970       {
38971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38972       };
38973     } catch (Dali::DaliException e) {
38974       {
38975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38976       };
38977     } catch (...) {
38978       {
38979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38980       };
38981     }
38982   }
38983
38984 }
38985
38986
38987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
38988   void * jresult ;
38989   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38990   Dali::CustomActor result;
38991
38992   arg1 = (Dali::CustomActorImpl *)jarg1;
38993   {
38994     try {
38995       result = ((Dali::CustomActorImpl const *)arg1)->Self();
38996     } catch (std::out_of_range& e) {
38997       {
38998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38999       };
39000     } catch (std::exception& e) {
39001       {
39002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39003       };
39004     } catch (Dali::DaliException e) {
39005       {
39006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39007       };
39008     } catch (...) {
39009       {
39010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39011       };
39012     }
39013   }
39014
39015   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39016   return jresult;
39017 }
39018
39019
39020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
39021   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39022   int arg2 ;
39023
39024   arg1 = (Dali::CustomActorImpl *)jarg1;
39025   arg2 = (int)jarg2;
39026   {
39027     try {
39028       (arg1)->OnStageConnection(arg2);
39029     } catch (std::out_of_range& e) {
39030       {
39031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39032       };
39033     } catch (std::exception& e) {
39034       {
39035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39036       };
39037     } catch (Dali::DaliException e) {
39038       {
39039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39040       };
39041     } catch (...) {
39042       {
39043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39044       };
39045     }
39046   }
39047
39048 }
39049
39050
39051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
39052   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39053
39054   arg1 = (Dali::CustomActorImpl *)jarg1;
39055   {
39056     try {
39057       (arg1)->OnStageDisconnection();
39058     } catch (std::out_of_range& e) {
39059       {
39060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39061       };
39062     } catch (std::exception& e) {
39063       {
39064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39065       };
39066     } catch (Dali::DaliException e) {
39067       {
39068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39069       };
39070     } catch (...) {
39071       {
39072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39073       };
39074     }
39075   }
39076
39077 }
39078
39079
39080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
39081   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39082   Dali::Actor *arg2 = 0 ;
39083
39084   arg1 = (Dali::CustomActorImpl *)jarg1;
39085   arg2 = (Dali::Actor *)jarg2;
39086   if (!arg2) {
39087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39088     return ;
39089   }
39090   {
39091     try {
39092       (arg1)->OnChildAdd(*arg2);
39093     } catch (std::out_of_range& e) {
39094       {
39095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39096       };
39097     } catch (std::exception& e) {
39098       {
39099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39100       };
39101     } catch (Dali::DaliException e) {
39102       {
39103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39104       };
39105     } catch (...) {
39106       {
39107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39108       };
39109     }
39110   }
39111
39112 }
39113
39114
39115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
39116   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39117   Dali::Actor *arg2 = 0 ;
39118
39119   arg1 = (Dali::CustomActorImpl *)jarg1;
39120   arg2 = (Dali::Actor *)jarg2;
39121   if (!arg2) {
39122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39123     return ;
39124   }
39125   {
39126     try {
39127       (arg1)->OnChildRemove(*arg2);
39128     } catch (std::out_of_range& e) {
39129       {
39130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39131       };
39132     } catch (std::exception& e) {
39133       {
39134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39135       };
39136     } catch (Dali::DaliException e) {
39137       {
39138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39139       };
39140     } catch (...) {
39141       {
39142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39143       };
39144     }
39145   }
39146
39147 }
39148
39149
39150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
39151   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39152   Dali::Property::Index arg2 ;
39153   Dali::Property::Value arg3 ;
39154   Dali::Property::Value *argp3 ;
39155
39156   arg1 = (Dali::CustomActorImpl *)jarg1;
39157   arg2 = (Dali::Property::Index)jarg2;
39158   argp3 = (Dali::Property::Value *)jarg3;
39159   if (!argp3) {
39160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39161     return ;
39162   }
39163   arg3 = *argp3;
39164   {
39165     try {
39166       (arg1)->OnPropertySet(arg2,arg3);
39167     } catch (std::out_of_range& e) {
39168       {
39169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39170       };
39171     } catch (std::exception& e) {
39172       {
39173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39174       };
39175     } catch (Dali::DaliException e) {
39176       {
39177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39178       };
39179     } catch (...) {
39180       {
39181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39182       };
39183     }
39184   }
39185
39186 }
39187
39188
39189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
39190   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39191   Dali::Vector3 *arg2 = 0 ;
39192
39193   arg1 = (Dali::CustomActorImpl *)jarg1;
39194   arg2 = (Dali::Vector3 *)jarg2;
39195   if (!arg2) {
39196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39197     return ;
39198   }
39199   {
39200     try {
39201       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
39202     } catch (std::out_of_range& e) {
39203       {
39204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39205       };
39206     } catch (std::exception& e) {
39207       {
39208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39209       };
39210     } catch (Dali::DaliException e) {
39211       {
39212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39213       };
39214     } catch (...) {
39215       {
39216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39217       };
39218     }
39219   }
39220
39221 }
39222
39223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
39224   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39225   Dali::Animation *arg2 = 0 ;
39226   Dali::Vector3 *arg3 = 0 ;
39227
39228   arg1 = (Dali::CustomActorImpl *)jarg1;
39229   arg2 = (Dali::Animation *)jarg2;
39230   if (!arg2) {
39231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
39232     return ;
39233   }
39234   arg3 = (Dali::Vector3 *)jarg3;
39235   if (!arg3) {
39236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39237     return ;
39238   }
39239   {
39240     try {
39241       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
39242     } catch (std::out_of_range& e) {
39243       {
39244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39245       };
39246     } catch (std::exception& e) {
39247       {
39248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39249       };
39250     } catch (Dali::DaliException e) {
39251       {
39252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39253       };
39254     } catch (...) {
39255       {
39256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39257       };
39258     }
39259   }
39260
39261 }
39262
39263
39264 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
39265   unsigned int jresult ;
39266   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39267   Dali::TouchEvent *arg2 = 0 ;
39268   bool result;
39269
39270   arg1 = (Dali::CustomActorImpl *)jarg1;
39271   arg2 = (Dali::TouchEvent *)jarg2;
39272   if (!arg2) {
39273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
39274     return 0;
39275   }
39276   {
39277     try {
39278       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
39279     } catch (std::out_of_range& e) {
39280       {
39281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39282       };
39283     } catch (std::exception& e) {
39284       {
39285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39286       };
39287     } catch (Dali::DaliException e) {
39288       {
39289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39290       };
39291     } catch (...) {
39292       {
39293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39294       };
39295     }
39296   }
39297
39298   jresult = result;
39299   return jresult;
39300 }
39301
39302
39303 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
39304   unsigned int jresult ;
39305   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39306   Dali::HoverEvent *arg2 = 0 ;
39307   bool result;
39308
39309   arg1 = (Dali::CustomActorImpl *)jarg1;
39310   arg2 = (Dali::HoverEvent *)jarg2;
39311   if (!arg2) {
39312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
39313     return 0;
39314   }
39315   {
39316     try {
39317       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
39318     } catch (std::out_of_range& e) {
39319       {
39320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39321       };
39322     } catch (std::exception& e) {
39323       {
39324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39325       };
39326     } catch (Dali::DaliException e) {
39327       {
39328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39329       };
39330     } catch (...) {
39331       {
39332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39333       };
39334     }
39335   }
39336
39337   jresult = result;
39338   return jresult;
39339 }
39340
39341
39342 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
39343   unsigned int jresult ;
39344   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39345   Dali::KeyEvent *arg2 = 0 ;
39346   bool result;
39347
39348   arg1 = (Dali::CustomActorImpl *)jarg1;
39349   arg2 = (Dali::KeyEvent *)jarg2;
39350   if (!arg2) {
39351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
39352     return 0;
39353   }
39354   {
39355     try {
39356       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
39357     } catch (std::out_of_range& e) {
39358       {
39359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39360       };
39361     } catch (std::exception& e) {
39362       {
39363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39364       };
39365     } catch (Dali::DaliException e) {
39366       {
39367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39368       };
39369     } catch (...) {
39370       {
39371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39372       };
39373     }
39374   }
39375
39376   jresult = result;
39377   return jresult;
39378 }
39379
39380
39381 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
39382   unsigned int jresult ;
39383   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39384   Dali::WheelEvent *arg2 = 0 ;
39385   bool result;
39386
39387   arg1 = (Dali::CustomActorImpl *)jarg1;
39388   arg2 = (Dali::WheelEvent *)jarg2;
39389   if (!arg2) {
39390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
39391     return 0;
39392   }
39393   {
39394     try {
39395       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
39396     } catch (std::out_of_range& e) {
39397       {
39398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39399       };
39400     } catch (std::exception& e) {
39401       {
39402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39403       };
39404     } catch (Dali::DaliException e) {
39405       {
39406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39407       };
39408     } catch (...) {
39409       {
39410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39411       };
39412     }
39413   }
39414
39415   jresult = result;
39416   return jresult;
39417 }
39418
39419
39420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
39421   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39422   Dali::Vector2 *arg2 = 0 ;
39423   Dali::RelayoutContainer *arg3 = 0 ;
39424
39425   arg1 = (Dali::CustomActorImpl *)jarg1;
39426   arg2 = (Dali::Vector2 *)jarg2;
39427   if (!arg2) {
39428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39429     return ;
39430   }
39431   arg3 = (Dali::RelayoutContainer *)jarg3;
39432   if (!arg3) {
39433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
39434     return ;
39435   }
39436   {
39437     try {
39438       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
39439     } catch (std::out_of_range& e) {
39440       {
39441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39442       };
39443     } catch (std::exception& e) {
39444       {
39445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39446       };
39447     } catch (Dali::DaliException e) {
39448       {
39449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39450       };
39451     } catch (...) {
39452       {
39453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39454       };
39455     }
39456   }
39457
39458 }
39459
39460
39461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
39462   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39463   Dali::ResizePolicy::Type arg2 ;
39464   Dali::Dimension::Type arg3 ;
39465
39466   arg1 = (Dali::CustomActorImpl *)jarg1;
39467   arg2 = (Dali::ResizePolicy::Type)jarg2;
39468   arg3 = (Dali::Dimension::Type)jarg3;
39469   {
39470     try {
39471       (arg1)->OnSetResizePolicy(arg2,arg3);
39472     } catch (std::out_of_range& e) {
39473       {
39474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39475       };
39476     } catch (std::exception& e) {
39477       {
39478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39479       };
39480     } catch (Dali::DaliException e) {
39481       {
39482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39483       };
39484     } catch (...) {
39485       {
39486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39487       };
39488     }
39489   }
39490
39491 }
39492
39493
39494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
39495   void * jresult ;
39496   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39497   Dali::Vector3 result;
39498
39499   arg1 = (Dali::CustomActorImpl *)jarg1;
39500   {
39501     try {
39502       result = (arg1)->GetNaturalSize();
39503     } catch (std::out_of_range& e) {
39504       {
39505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39506       };
39507     } catch (std::exception& e) {
39508       {
39509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39510       };
39511     } catch (Dali::DaliException e) {
39512       {
39513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39514       };
39515     } catch (...) {
39516       {
39517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39518       };
39519     }
39520   }
39521
39522   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
39523   return jresult;
39524 }
39525
39526
39527 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
39528   float jresult ;
39529   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39530   Dali::Actor *arg2 = 0 ;
39531   Dali::Dimension::Type arg3 ;
39532   float result;
39533
39534   arg1 = (Dali::CustomActorImpl *)jarg1;
39535   arg2 = (Dali::Actor *)jarg2;
39536   if (!arg2) {
39537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39538     return 0;
39539   }
39540   arg3 = (Dali::Dimension::Type)jarg3;
39541   {
39542     try {
39543       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
39544     } catch (std::out_of_range& e) {
39545       {
39546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39547       };
39548     } catch (std::exception& e) {
39549       {
39550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39551       };
39552     } catch (Dali::DaliException e) {
39553       {
39554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39555       };
39556     } catch (...) {
39557       {
39558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39559       };
39560     }
39561   }
39562
39563   jresult = result;
39564   return jresult;
39565 }
39566
39567
39568 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39569   float jresult ;
39570   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39571   float arg2 ;
39572   float result;
39573
39574   arg1 = (Dali::CustomActorImpl *)jarg1;
39575   arg2 = (float)jarg2;
39576   {
39577     try {
39578       result = (float)(arg1)->GetHeightForWidth(arg2);
39579     } catch (std::out_of_range& e) {
39580       {
39581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39582       };
39583     } catch (std::exception& e) {
39584       {
39585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39586       };
39587     } catch (Dali::DaliException e) {
39588       {
39589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39590       };
39591     } catch (...) {
39592       {
39593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39594       };
39595     }
39596   }
39597
39598   jresult = result;
39599   return jresult;
39600 }
39601
39602
39603 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39604   float jresult ;
39605   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39606   float arg2 ;
39607   float result;
39608
39609   arg1 = (Dali::CustomActorImpl *)jarg1;
39610   arg2 = (float)jarg2;
39611   {
39612     try {
39613       result = (float)(arg1)->GetWidthForHeight(arg2);
39614     } catch (std::out_of_range& e) {
39615       {
39616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39617       };
39618     } catch (std::exception& e) {
39619       {
39620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39621       };
39622     } catch (Dali::DaliException e) {
39623       {
39624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39625       };
39626     } catch (...) {
39627       {
39628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39629       };
39630     }
39631   }
39632
39633   jresult = result;
39634   return jresult;
39635 }
39636
39637
39638 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39639   unsigned int jresult ;
39640   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39641   Dali::Dimension::Type arg2 ;
39642   bool result;
39643
39644   arg1 = (Dali::CustomActorImpl *)jarg1;
39645   arg2 = (Dali::Dimension::Type)jarg2;
39646   {
39647     try {
39648       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39649     } catch (std::out_of_range& e) {
39650       {
39651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39652       };
39653     } catch (std::exception& e) {
39654       {
39655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39656       };
39657     } catch (Dali::DaliException e) {
39658       {
39659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39660       };
39661     } catch (...) {
39662       {
39663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39664       };
39665     }
39666   }
39667
39668   jresult = result;
39669   return jresult;
39670 }
39671
39672
39673 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
39674   unsigned int jresult ;
39675   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39676   bool result;
39677
39678   arg1 = (Dali::CustomActorImpl *)jarg1;
39679   {
39680     try {
39681       result = (bool)(arg1)->RelayoutDependentOnChildren();
39682     } catch (std::out_of_range& e) {
39683       {
39684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39685       };
39686     } catch (std::exception& e) {
39687       {
39688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39689       };
39690     } catch (Dali::DaliException e) {
39691       {
39692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39693       };
39694     } catch (...) {
39695       {
39696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39697       };
39698     }
39699   }
39700
39701   jresult = result;
39702   return jresult;
39703 }
39704
39705
39706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
39707   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39708   Dali::Dimension::Type arg2 ;
39709
39710   arg1 = (Dali::CustomActorImpl *)jarg1;
39711   arg2 = (Dali::Dimension::Type)jarg2;
39712   {
39713     try {
39714       (arg1)->OnCalculateRelayoutSize(arg2);
39715     } catch (std::out_of_range& e) {
39716       {
39717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39718       };
39719     } catch (std::exception& e) {
39720       {
39721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39722       };
39723     } catch (Dali::DaliException e) {
39724       {
39725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39726       };
39727     } catch (...) {
39728       {
39729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39730       };
39731     }
39732   }
39733
39734 }
39735
39736
39737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
39738   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39739   float arg2 ;
39740   Dali::Dimension::Type arg3 ;
39741
39742   arg1 = (Dali::CustomActorImpl *)jarg1;
39743   arg2 = (float)jarg2;
39744   arg3 = (Dali::Dimension::Type)jarg3;
39745   {
39746     try {
39747       (arg1)->OnLayoutNegotiated(arg2,arg3);
39748     } catch (std::out_of_range& e) {
39749       {
39750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39751       };
39752     } catch (std::exception& e) {
39753       {
39754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39755       };
39756     } catch (Dali::DaliException e) {
39757       {
39758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39759       };
39760     } catch (...) {
39761       {
39762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39763       };
39764     }
39765   }
39766
39767 }
39768
39769
39770 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
39771   unsigned int jresult ;
39772   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39773   bool result;
39774
39775   arg1 = (Dali::CustomActorImpl *)jarg1;
39776   {
39777     try {
39778       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
39779     } catch (std::out_of_range& e) {
39780       {
39781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39782       };
39783     } catch (std::exception& e) {
39784       {
39785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39786       };
39787     } catch (Dali::DaliException e) {
39788       {
39789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39790       };
39791     } catch (...) {
39792       {
39793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39794       };
39795     }
39796   }
39797
39798   jresult = result;
39799   return jresult;
39800 }
39801
39802
39803 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
39804   unsigned int jresult ;
39805   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39806   bool result;
39807
39808   arg1 = (Dali::CustomActorImpl *)jarg1;
39809   {
39810     try {
39811       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
39812     } catch (std::out_of_range& e) {
39813       {
39814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39815       };
39816     } catch (std::exception& e) {
39817       {
39818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39819       };
39820     } catch (Dali::DaliException e) {
39821       {
39822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39823       };
39824     } catch (...) {
39825       {
39826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39827       };
39828     }
39829   }
39830
39831   jresult = result;
39832   return jresult;
39833 }
39834
39835
39836 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
39837   unsigned int jresult ;
39838   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39839   bool result;
39840
39841   arg1 = (Dali::CustomActorImpl *)jarg1;
39842   {
39843     try {
39844       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
39845     } catch (std::out_of_range& e) {
39846       {
39847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39848       };
39849     } catch (std::exception& e) {
39850       {
39851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39852       };
39853     } catch (Dali::DaliException e) {
39854       {
39855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39856       };
39857     } catch (...) {
39858       {
39859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39860       };
39861     }
39862   }
39863
39864   jresult = result;
39865   return jresult;
39866 }
39867
39868
39869 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
39870   unsigned int jresult ;
39871   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39872   bool result;
39873
39874   arg1 = (Dali::CustomActorImpl *)jarg1;
39875   {
39876     try {
39877       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
39878     } catch (std::out_of_range& e) {
39879       {
39880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39881       };
39882     } catch (std::exception& e) {
39883       {
39884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39885       };
39886     } catch (Dali::DaliException e) {
39887       {
39888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39889       };
39890     } catch (...) {
39891       {
39892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39893       };
39894     }
39895   }
39896
39897   jresult = result;
39898   return jresult;
39899 }
39900
39901
39902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
39903   void * jresult ;
39904   Dali::CustomActor *result = 0 ;
39905
39906   {
39907     try {
39908       result = (Dali::CustomActor *)new Dali::CustomActor();
39909     } catch (std::out_of_range& e) {
39910       {
39911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39912       };
39913     } catch (std::exception& e) {
39914       {
39915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39916       };
39917     } catch (Dali::DaliException e) {
39918       {
39919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39920       };
39921     } catch (...) {
39922       {
39923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39924       };
39925     }
39926   }
39927
39928   jresult = (void *)result;
39929   return jresult;
39930 }
39931
39932
39933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
39934   void * jresult ;
39935   Dali::BaseHandle arg1 ;
39936   Dali::BaseHandle *argp1 ;
39937   Dali::CustomActor result;
39938
39939   argp1 = (Dali::BaseHandle *)jarg1;
39940   if (!argp1) {
39941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39942     return 0;
39943   }
39944   arg1 = *argp1;
39945   {
39946     try {
39947       result = Dali::CustomActor::DownCast(arg1);
39948     } catch (std::out_of_range& e) {
39949       {
39950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39951       };
39952     } catch (std::exception& e) {
39953       {
39954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39955       };
39956     } catch (Dali::DaliException e) {
39957       {
39958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39959       };
39960     } catch (...) {
39961       {
39962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39963       };
39964     }
39965   }
39966
39967   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39968   return jresult;
39969 }
39970
39971
39972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
39973   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
39974
39975   arg1 = (Dali::CustomActor *)jarg1;
39976   {
39977     try {
39978       delete arg1;
39979     } catch (std::out_of_range& e) {
39980       {
39981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39982       };
39983     } catch (std::exception& e) {
39984       {
39985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39986       };
39987     } catch (Dali::DaliException e) {
39988       {
39989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39990       };
39991     } catch (...) {
39992       {
39993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39994       };
39995     }
39996   }
39997
39998 }
39999
40000
40001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
40002   void * jresult ;
40003   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40004   Dali::CustomActorImpl *result = 0 ;
40005
40006   arg1 = (Dali::CustomActor *)jarg1;
40007   {
40008     try {
40009       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
40010     } catch (std::out_of_range& e) {
40011       {
40012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40013       };
40014     } catch (std::exception& e) {
40015       {
40016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40017       };
40018     } catch (Dali::DaliException e) {
40019       {
40020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40021       };
40022     } catch (...) {
40023       {
40024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40025       };
40026     }
40027   }
40028
40029   jresult = (void *)result;
40030   return jresult;
40031 }
40032
40033
40034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
40035   void * jresult ;
40036   Dali::CustomActorImpl *arg1 = 0 ;
40037   Dali::CustomActor *result = 0 ;
40038
40039   arg1 = (Dali::CustomActorImpl *)jarg1;
40040   if (!arg1) {
40041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
40042     return 0;
40043   }
40044   {
40045     try {
40046       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
40047     } catch (std::out_of_range& e) {
40048       {
40049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40050       };
40051     } catch (std::exception& e) {
40052       {
40053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40054       };
40055     } catch (Dali::DaliException e) {
40056       {
40057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40058       };
40059     } catch (...) {
40060       {
40061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40062       };
40063     }
40064   }
40065
40066   jresult = (void *)result;
40067   return jresult;
40068 }
40069
40070
40071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
40072   void * jresult ;
40073   Dali::CustomActor *arg1 = 0 ;
40074   Dali::CustomActor *result = 0 ;
40075
40076   arg1 = (Dali::CustomActor *)jarg1;
40077   if (!arg1) {
40078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40079     return 0;
40080   }
40081   {
40082     try {
40083       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
40084     } catch (std::out_of_range& e) {
40085       {
40086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40087       };
40088     } catch (std::exception& e) {
40089       {
40090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40091       };
40092     } catch (Dali::DaliException e) {
40093       {
40094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40095       };
40096     } catch (...) {
40097       {
40098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40099       };
40100     }
40101   }
40102
40103   jresult = (void *)result;
40104   return jresult;
40105 }
40106
40107
40108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
40109   void * jresult ;
40110   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40111   Dali::CustomActor *arg2 = 0 ;
40112   Dali::CustomActor *result = 0 ;
40113
40114   arg1 = (Dali::CustomActor *)jarg1;
40115   arg2 = (Dali::CustomActor *)jarg2;
40116   if (!arg2) {
40117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40118     return 0;
40119   }
40120   {
40121     try {
40122       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
40123     } catch (std::out_of_range& e) {
40124       {
40125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40126       };
40127     } catch (std::exception& e) {
40128       {
40129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40130       };
40131     } catch (Dali::DaliException e) {
40132       {
40133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40134       };
40135     } catch (...) {
40136       {
40137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40138       };
40139     }
40140   }
40141
40142   jresult = (void *)result;
40143   return jresult;
40144 }
40145
40146
40147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
40148   int jresult ;
40149   int result;
40150
40151   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
40152   jresult = (int)result;
40153   return jresult;
40154 }
40155
40156
40157 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
40158   int jresult ;
40159   int result;
40160
40161   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
40162   jresult = (int)result;
40163   return jresult;
40164 }
40165
40166
40167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
40168   int jresult ;
40169   int result;
40170
40171   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
40172   jresult = (int)result;
40173   return jresult;
40174 }
40175
40176
40177 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
40178   int jresult ;
40179   int result;
40180
40181   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
40182   jresult = (int)result;
40183   return jresult;
40184 }
40185
40186
40187 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
40188   int jresult ;
40189   int result;
40190
40191   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
40192   jresult = (int)result;
40193   return jresult;
40194 }
40195
40196
40197 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
40198   int jresult ;
40199   int result;
40200
40201   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
40202   jresult = (int)result;
40203   return jresult;
40204 }
40205
40206
40207 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
40208   int jresult ;
40209   int result;
40210
40211   result = (int)Dali::PanGestureDetector::Property::PANNING;
40212   jresult = (int)result;
40213   return jresult;
40214 }
40215
40216
40217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
40218   void * jresult ;
40219   Dali::PanGestureDetector::Property *result = 0 ;
40220
40221   {
40222     try {
40223       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
40224     } catch (std::out_of_range& e) {
40225       {
40226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40227       };
40228     } catch (std::exception& e) {
40229       {
40230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40231       };
40232     } catch (Dali::DaliException e) {
40233       {
40234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40235       };
40236     } catch (...) {
40237       {
40238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40239       };
40240     }
40241   }
40242
40243   jresult = (void *)result;
40244   return jresult;
40245 }
40246
40247
40248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
40249   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
40250
40251   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
40252   {
40253     try {
40254       delete arg1;
40255     } catch (std::out_of_range& e) {
40256       {
40257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40258       };
40259     } catch (std::exception& e) {
40260       {
40261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40262       };
40263     } catch (Dali::DaliException e) {
40264       {
40265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40266       };
40267     } catch (...) {
40268       {
40269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40270       };
40271     }
40272   }
40273
40274 }
40275
40276
40277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
40278   void * jresult ;
40279   Dali::Radian *result = 0 ;
40280
40281   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
40282   jresult = (void *)result;
40283   return jresult;
40284 }
40285
40286
40287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
40288   void * jresult ;
40289   Dali::Radian *result = 0 ;
40290
40291   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
40292   jresult = (void *)result;
40293   return jresult;
40294 }
40295
40296
40297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
40298   void * jresult ;
40299   Dali::Radian *result = 0 ;
40300
40301   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
40302   jresult = (void *)result;
40303   return jresult;
40304 }
40305
40306
40307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
40308   void * jresult ;
40309   Dali::Radian *result = 0 ;
40310
40311   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
40312   jresult = (void *)result;
40313   return jresult;
40314 }
40315
40316
40317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
40318   void * jresult ;
40319   Dali::Radian *result = 0 ;
40320
40321   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
40322   jresult = (void *)result;
40323   return jresult;
40324 }
40325
40326
40327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
40328   void * jresult ;
40329   Dali::Radian *result = 0 ;
40330
40331   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
40332   jresult = (void *)result;
40333   return jresult;
40334 }
40335
40336
40337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
40338   void * jresult ;
40339   Dali::Radian *result = 0 ;
40340
40341   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
40342   jresult = (void *)result;
40343   return jresult;
40344 }
40345
40346
40347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
40348   void * jresult ;
40349   Dali::PanGestureDetector *result = 0 ;
40350
40351   {
40352     try {
40353       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
40354     } catch (std::out_of_range& e) {
40355       {
40356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40357       };
40358     } catch (std::exception& e) {
40359       {
40360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40361       };
40362     } catch (Dali::DaliException e) {
40363       {
40364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40365       };
40366     } catch (...) {
40367       {
40368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40369       };
40370     }
40371   }
40372
40373   jresult = (void *)result;
40374   return jresult;
40375 }
40376
40377
40378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
40379   void * jresult ;
40380   Dali::PanGestureDetector result;
40381
40382   {
40383     try {
40384       result = Dali::PanGestureDetector::New();
40385     } catch (std::out_of_range& e) {
40386       {
40387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40388       };
40389     } catch (std::exception& e) {
40390       {
40391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40392       };
40393     } catch (Dali::DaliException e) {
40394       {
40395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40396       };
40397     } catch (...) {
40398       {
40399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40400       };
40401     }
40402   }
40403
40404   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40405   return jresult;
40406 }
40407
40408
40409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
40410   void * jresult ;
40411   Dali::BaseHandle arg1 ;
40412   Dali::BaseHandle *argp1 ;
40413   Dali::PanGestureDetector result;
40414
40415   argp1 = (Dali::BaseHandle *)jarg1;
40416   if (!argp1) {
40417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40418     return 0;
40419   }
40420   arg1 = *argp1;
40421   {
40422     try {
40423       result = Dali::PanGestureDetector::DownCast(arg1);
40424     } catch (std::out_of_range& e) {
40425       {
40426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40427       };
40428     } catch (std::exception& e) {
40429       {
40430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40431       };
40432     } catch (Dali::DaliException e) {
40433       {
40434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40435       };
40436     } catch (...) {
40437       {
40438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40439       };
40440     }
40441   }
40442
40443   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40444   return jresult;
40445 }
40446
40447
40448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
40449   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40450
40451   arg1 = (Dali::PanGestureDetector *)jarg1;
40452   {
40453     try {
40454       delete arg1;
40455     } catch (std::out_of_range& e) {
40456       {
40457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40458       };
40459     } catch (std::exception& e) {
40460       {
40461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40462       };
40463     } catch (Dali::DaliException e) {
40464       {
40465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40466       };
40467     } catch (...) {
40468       {
40469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40470       };
40471     }
40472   }
40473
40474 }
40475
40476
40477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
40478   void * jresult ;
40479   Dali::PanGestureDetector *arg1 = 0 ;
40480   Dali::PanGestureDetector *result = 0 ;
40481
40482   arg1 = (Dali::PanGestureDetector *)jarg1;
40483   if (!arg1) {
40484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40485     return 0;
40486   }
40487   {
40488     try {
40489       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
40490     } catch (std::out_of_range& e) {
40491       {
40492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40493       };
40494     } catch (std::exception& e) {
40495       {
40496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40497       };
40498     } catch (Dali::DaliException e) {
40499       {
40500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40501       };
40502     } catch (...) {
40503       {
40504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40505       };
40506     }
40507   }
40508
40509   jresult = (void *)result;
40510   return jresult;
40511 }
40512
40513
40514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
40515   void * jresult ;
40516   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40517   Dali::PanGestureDetector *arg2 = 0 ;
40518   Dali::PanGestureDetector *result = 0 ;
40519
40520   arg1 = (Dali::PanGestureDetector *)jarg1;
40521   arg2 = (Dali::PanGestureDetector *)jarg2;
40522   if (!arg2) {
40523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40524     return 0;
40525   }
40526   {
40527     try {
40528       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
40529     } catch (std::out_of_range& e) {
40530       {
40531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40532       };
40533     } catch (std::exception& e) {
40534       {
40535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40536       };
40537     } catch (Dali::DaliException e) {
40538       {
40539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40540       };
40541     } catch (...) {
40542       {
40543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40544       };
40545     }
40546   }
40547
40548   jresult = (void *)result;
40549   return jresult;
40550 }
40551
40552
40553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
40554   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40555   unsigned int arg2 ;
40556
40557   arg1 = (Dali::PanGestureDetector *)jarg1;
40558   arg2 = (unsigned int)jarg2;
40559   {
40560     try {
40561       (arg1)->SetMinimumTouchesRequired(arg2);
40562     } catch (std::out_of_range& e) {
40563       {
40564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40565       };
40566     } catch (std::exception& e) {
40567       {
40568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40569       };
40570     } catch (Dali::DaliException e) {
40571       {
40572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40573       };
40574     } catch (...) {
40575       {
40576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40577       };
40578     }
40579   }
40580
40581 }
40582
40583
40584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
40585   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40586   unsigned int arg2 ;
40587
40588   arg1 = (Dali::PanGestureDetector *)jarg1;
40589   arg2 = (unsigned int)jarg2;
40590   {
40591     try {
40592       (arg1)->SetMaximumTouchesRequired(arg2);
40593     } catch (std::out_of_range& e) {
40594       {
40595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40596       };
40597     } catch (std::exception& e) {
40598       {
40599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40600       };
40601     } catch (Dali::DaliException e) {
40602       {
40603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40604       };
40605     } catch (...) {
40606       {
40607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40608       };
40609     }
40610   }
40611
40612 }
40613
40614
40615 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40616   unsigned int jresult ;
40617   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40618   unsigned int result;
40619
40620   arg1 = (Dali::PanGestureDetector *)jarg1;
40621   {
40622     try {
40623       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40624     } catch (std::out_of_range& e) {
40625       {
40626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40627       };
40628     } catch (std::exception& e) {
40629       {
40630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40631       };
40632     } catch (Dali::DaliException e) {
40633       {
40634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40635       };
40636     } catch (...) {
40637       {
40638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40639       };
40640     }
40641   }
40642
40643   jresult = result;
40644   return jresult;
40645 }
40646
40647
40648 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40649   unsigned int jresult ;
40650   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40651   unsigned int result;
40652
40653   arg1 = (Dali::PanGestureDetector *)jarg1;
40654   {
40655     try {
40656       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
40657     } catch (std::out_of_range& e) {
40658       {
40659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40660       };
40661     } catch (std::exception& e) {
40662       {
40663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40664       };
40665     } catch (Dali::DaliException e) {
40666       {
40667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40668       };
40669     } catch (...) {
40670       {
40671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40672       };
40673     }
40674   }
40675
40676   jresult = result;
40677   return jresult;
40678 }
40679
40680
40681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40682   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40683   Dali::Radian arg2 ;
40684   Dali::Radian arg3 ;
40685   Dali::Radian *argp2 ;
40686   Dali::Radian *argp3 ;
40687
40688   arg1 = (Dali::PanGestureDetector *)jarg1;
40689   argp2 = (Dali::Radian *)jarg2;
40690   if (!argp2) {
40691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40692     return ;
40693   }
40694   arg2 = *argp2;
40695   argp3 = (Dali::Radian *)jarg3;
40696   if (!argp3) {
40697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40698     return ;
40699   }
40700   arg3 = *argp3;
40701   {
40702     try {
40703       (arg1)->AddAngle(arg2,arg3);
40704     } catch (std::out_of_range& e) {
40705       {
40706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40707       };
40708     } catch (std::exception& e) {
40709       {
40710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40711       };
40712     } catch (Dali::DaliException e) {
40713       {
40714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40715       };
40716     } catch (...) {
40717       {
40718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40719       };
40720     }
40721   }
40722
40723 }
40724
40725
40726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
40727   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40728   Dali::Radian arg2 ;
40729   Dali::Radian *argp2 ;
40730
40731   arg1 = (Dali::PanGestureDetector *)jarg1;
40732   argp2 = (Dali::Radian *)jarg2;
40733   if (!argp2) {
40734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40735     return ;
40736   }
40737   arg2 = *argp2;
40738   {
40739     try {
40740       (arg1)->AddAngle(arg2);
40741     } catch (std::out_of_range& e) {
40742       {
40743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40744       };
40745     } catch (std::exception& e) {
40746       {
40747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40748       };
40749     } catch (Dali::DaliException e) {
40750       {
40751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40752       };
40753     } catch (...) {
40754       {
40755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40756       };
40757     }
40758   }
40759
40760 }
40761
40762
40763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40764   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40765   Dali::Radian arg2 ;
40766   Dali::Radian arg3 ;
40767   Dali::Radian *argp2 ;
40768   Dali::Radian *argp3 ;
40769
40770   arg1 = (Dali::PanGestureDetector *)jarg1;
40771   argp2 = (Dali::Radian *)jarg2;
40772   if (!argp2) {
40773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40774     return ;
40775   }
40776   arg2 = *argp2;
40777   argp3 = (Dali::Radian *)jarg3;
40778   if (!argp3) {
40779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40780     return ;
40781   }
40782   arg3 = *argp3;
40783   {
40784     try {
40785       (arg1)->AddDirection(arg2,arg3);
40786     } catch (std::out_of_range& e) {
40787       {
40788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40789       };
40790     } catch (std::exception& e) {
40791       {
40792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40793       };
40794     } catch (Dali::DaliException e) {
40795       {
40796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40797       };
40798     } catch (...) {
40799       {
40800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40801       };
40802     }
40803   }
40804
40805 }
40806
40807
40808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
40809   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40810   Dali::Radian arg2 ;
40811   Dali::Radian *argp2 ;
40812
40813   arg1 = (Dali::PanGestureDetector *)jarg1;
40814   argp2 = (Dali::Radian *)jarg2;
40815   if (!argp2) {
40816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40817     return ;
40818   }
40819   arg2 = *argp2;
40820   {
40821     try {
40822       (arg1)->AddDirection(arg2);
40823     } catch (std::out_of_range& e) {
40824       {
40825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40826       };
40827     } catch (std::exception& e) {
40828       {
40829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40830       };
40831     } catch (Dali::DaliException e) {
40832       {
40833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40834       };
40835     } catch (...) {
40836       {
40837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40838       };
40839     }
40840   }
40841
40842 }
40843
40844
40845 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
40846   unsigned long jresult ;
40847   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40848   size_t result;
40849
40850   arg1 = (Dali::PanGestureDetector *)jarg1;
40851   {
40852     try {
40853       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
40854     } catch (std::out_of_range& e) {
40855       {
40856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40857       };
40858     } catch (std::exception& e) {
40859       {
40860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40861       };
40862     } catch (Dali::DaliException e) {
40863       {
40864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40865       };
40866     } catch (...) {
40867       {
40868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40869       };
40870     }
40871   }
40872
40873   jresult = (unsigned long)result;
40874   return jresult;
40875 }
40876
40877
40878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
40879   void * jresult ;
40880   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40881   size_t arg2 ;
40882   Dali::PanGestureDetector::AngleThresholdPair result;
40883
40884   arg1 = (Dali::PanGestureDetector *)jarg1;
40885   arg2 = (size_t)jarg2;
40886   {
40887     try {
40888       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
40889     } catch (std::out_of_range& e) {
40890       {
40891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40892       };
40893     } catch (std::exception& e) {
40894       {
40895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40896       };
40897     } catch (Dali::DaliException e) {
40898       {
40899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40900       };
40901     } catch (...) {
40902       {
40903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40904       };
40905     }
40906   }
40907
40908   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
40909   return jresult;
40910 }
40911
40912
40913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
40914   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40915
40916   arg1 = (Dali::PanGestureDetector *)jarg1;
40917   {
40918     try {
40919       (arg1)->ClearAngles();
40920     } catch (std::out_of_range& e) {
40921       {
40922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40923       };
40924     } catch (std::exception& e) {
40925       {
40926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40927       };
40928     } catch (Dali::DaliException e) {
40929       {
40930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40931       };
40932     } catch (...) {
40933       {
40934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40935       };
40936     }
40937   }
40938
40939 }
40940
40941
40942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
40943   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40944   Dali::Radian arg2 ;
40945   Dali::Radian *argp2 ;
40946
40947   arg1 = (Dali::PanGestureDetector *)jarg1;
40948   argp2 = (Dali::Radian *)jarg2;
40949   if (!argp2) {
40950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40951     return ;
40952   }
40953   arg2 = *argp2;
40954   {
40955     try {
40956       (arg1)->RemoveAngle(arg2);
40957     } catch (std::out_of_range& e) {
40958       {
40959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40960       };
40961     } catch (std::exception& e) {
40962       {
40963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40964       };
40965     } catch (Dali::DaliException e) {
40966       {
40967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40968       };
40969     } catch (...) {
40970       {
40971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40972       };
40973     }
40974   }
40975
40976 }
40977
40978
40979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
40980   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40981   Dali::Radian arg2 ;
40982   Dali::Radian *argp2 ;
40983
40984   arg1 = (Dali::PanGestureDetector *)jarg1;
40985   argp2 = (Dali::Radian *)jarg2;
40986   if (!argp2) {
40987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40988     return ;
40989   }
40990   arg2 = *argp2;
40991   {
40992     try {
40993       (arg1)->RemoveDirection(arg2);
40994     } catch (std::out_of_range& e) {
40995       {
40996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40997       };
40998     } catch (std::exception& e) {
40999       {
41000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41001       };
41002     } catch (Dali::DaliException e) {
41003       {
41004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41005       };
41006     } catch (...) {
41007       {
41008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41009       };
41010     }
41011   }
41012
41013 }
41014
41015
41016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
41017   void * jresult ;
41018   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41019   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
41020
41021   arg1 = (Dali::PanGestureDetector *)jarg1;
41022   {
41023     try {
41024       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41025     } catch (std::out_of_range& e) {
41026       {
41027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41028       };
41029     } catch (std::exception& e) {
41030       {
41031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41032       };
41033     } catch (Dali::DaliException e) {
41034       {
41035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41036       };
41037     } catch (...) {
41038       {
41039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41040       };
41041     }
41042   }
41043
41044   jresult = (void *)result;
41045   return jresult;
41046 }
41047
41048
41049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
41050   Dali::PanGesture *arg1 = 0 ;
41051
41052   arg1 = (Dali::PanGesture *)jarg1;
41053   if (!arg1) {
41054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41055     return ;
41056   }
41057   {
41058     try {
41059       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
41060     } catch (std::out_of_range& e) {
41061       {
41062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41063       };
41064     } catch (std::exception& e) {
41065       {
41066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41067       };
41068     } catch (Dali::DaliException e) {
41069       {
41070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41071       };
41072     } catch (...) {
41073       {
41074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41075       };
41076     }
41077   }
41078
41079 }
41080
41081
41082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
41083   void * jresult ;
41084   Dali::PanGesture *result = 0 ;
41085
41086   {
41087     try {
41088       result = (Dali::PanGesture *)new Dali::PanGesture();
41089     } catch (std::out_of_range& e) {
41090       {
41091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41092       };
41093     } catch (std::exception& e) {
41094       {
41095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41096       };
41097     } catch (Dali::DaliException e) {
41098       {
41099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41100       };
41101     } catch (...) {
41102       {
41103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41104       };
41105     }
41106   }
41107
41108   jresult = (void *)result;
41109   return jresult;
41110 }
41111
41112
41113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
41114   void * jresult ;
41115   Dali::Gesture::State arg1 ;
41116   Dali::PanGesture *result = 0 ;
41117
41118   arg1 = (Dali::Gesture::State)jarg1;
41119   {
41120     try {
41121       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
41122     } catch (std::out_of_range& e) {
41123       {
41124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41125       };
41126     } catch (std::exception& e) {
41127       {
41128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41129       };
41130     } catch (Dali::DaliException e) {
41131       {
41132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41133       };
41134     } catch (...) {
41135       {
41136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41137       };
41138     }
41139   }
41140
41141   jresult = (void *)result;
41142   return jresult;
41143 }
41144
41145
41146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
41147   void * jresult ;
41148   Dali::PanGesture *arg1 = 0 ;
41149   Dali::PanGesture *result = 0 ;
41150
41151   arg1 = (Dali::PanGesture *)jarg1;
41152   if (!arg1) {
41153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41154     return 0;
41155   }
41156   {
41157     try {
41158       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
41159     } catch (std::out_of_range& e) {
41160       {
41161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41162       };
41163     } catch (std::exception& e) {
41164       {
41165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41166       };
41167     } catch (Dali::DaliException e) {
41168       {
41169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41170       };
41171     } catch (...) {
41172       {
41173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41174       };
41175     }
41176   }
41177
41178   jresult = (void *)result;
41179   return jresult;
41180 }
41181
41182
41183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
41184   void * jresult ;
41185   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41186   Dali::PanGesture *arg2 = 0 ;
41187   Dali::PanGesture *result = 0 ;
41188
41189   arg1 = (Dali::PanGesture *)jarg1;
41190   arg2 = (Dali::PanGesture *)jarg2;
41191   if (!arg2) {
41192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41193     return 0;
41194   }
41195   {
41196     try {
41197       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
41198     } catch (std::out_of_range& e) {
41199       {
41200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41201       };
41202     } catch (std::exception& e) {
41203       {
41204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41205       };
41206     } catch (Dali::DaliException e) {
41207       {
41208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41209       };
41210     } catch (...) {
41211       {
41212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41213       };
41214     }
41215   }
41216
41217   jresult = (void *)result;
41218   return jresult;
41219 }
41220
41221
41222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
41223   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41224
41225   arg1 = (Dali::PanGesture *)jarg1;
41226   {
41227     try {
41228       delete arg1;
41229     } catch (std::out_of_range& e) {
41230       {
41231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41232       };
41233     } catch (std::exception& e) {
41234       {
41235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41236       };
41237     } catch (Dali::DaliException e) {
41238       {
41239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41240       };
41241     } catch (...) {
41242       {
41243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41244       };
41245     }
41246   }
41247
41248 }
41249
41250
41251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
41252   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41253   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41254
41255   arg1 = (Dali::PanGesture *)jarg1;
41256   arg2 = (Dali::Vector2 *)jarg2;
41257   if (arg1) (arg1)->velocity = *arg2;
41258 }
41259
41260
41261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
41262   void * jresult ;
41263   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41264   Dali::Vector2 *result = 0 ;
41265
41266   arg1 = (Dali::PanGesture *)jarg1;
41267   result = (Dali::Vector2 *)& ((arg1)->velocity);
41268   jresult = (void *)result;
41269   return jresult;
41270 }
41271
41272
41273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
41274   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41275   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41276
41277   arg1 = (Dali::PanGesture *)jarg1;
41278   arg2 = (Dali::Vector2 *)jarg2;
41279   if (arg1) (arg1)->displacement = *arg2;
41280 }
41281
41282
41283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
41284   void * jresult ;
41285   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41286   Dali::Vector2 *result = 0 ;
41287
41288   arg1 = (Dali::PanGesture *)jarg1;
41289   result = (Dali::Vector2 *)& ((arg1)->displacement);
41290   jresult = (void *)result;
41291   return jresult;
41292 }
41293
41294
41295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
41296   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41297   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41298
41299   arg1 = (Dali::PanGesture *)jarg1;
41300   arg2 = (Dali::Vector2 *)jarg2;
41301   if (arg1) (arg1)->position = *arg2;
41302 }
41303
41304
41305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
41306   void * jresult ;
41307   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41308   Dali::Vector2 *result = 0 ;
41309
41310   arg1 = (Dali::PanGesture *)jarg1;
41311   result = (Dali::Vector2 *)& ((arg1)->position);
41312   jresult = (void *)result;
41313   return jresult;
41314 }
41315
41316
41317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
41318   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41319   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41320
41321   arg1 = (Dali::PanGesture *)jarg1;
41322   arg2 = (Dali::Vector2 *)jarg2;
41323   if (arg1) (arg1)->screenVelocity = *arg2;
41324 }
41325
41326
41327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
41328   void * jresult ;
41329   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41330   Dali::Vector2 *result = 0 ;
41331
41332   arg1 = (Dali::PanGesture *)jarg1;
41333   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
41334   jresult = (void *)result;
41335   return jresult;
41336 }
41337
41338
41339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
41340   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41341   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41342
41343   arg1 = (Dali::PanGesture *)jarg1;
41344   arg2 = (Dali::Vector2 *)jarg2;
41345   if (arg1) (arg1)->screenDisplacement = *arg2;
41346 }
41347
41348
41349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
41350   void * jresult ;
41351   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41352   Dali::Vector2 *result = 0 ;
41353
41354   arg1 = (Dali::PanGesture *)jarg1;
41355   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
41356   jresult = (void *)result;
41357   return jresult;
41358 }
41359
41360
41361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
41362   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41363   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41364
41365   arg1 = (Dali::PanGesture *)jarg1;
41366   arg2 = (Dali::Vector2 *)jarg2;
41367   if (arg1) (arg1)->screenPosition = *arg2;
41368 }
41369
41370
41371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
41372   void * jresult ;
41373   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41374   Dali::Vector2 *result = 0 ;
41375
41376   arg1 = (Dali::PanGesture *)jarg1;
41377   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
41378   jresult = (void *)result;
41379   return jresult;
41380 }
41381
41382
41383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
41384   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41385   unsigned int arg2 ;
41386
41387   arg1 = (Dali::PanGesture *)jarg1;
41388   arg2 = (unsigned int)jarg2;
41389   if (arg1) (arg1)->numberOfTouches = arg2;
41390 }
41391
41392
41393 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
41394   unsigned int jresult ;
41395   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41396   unsigned int result;
41397
41398   arg1 = (Dali::PanGesture *)jarg1;
41399   result = (unsigned int) ((arg1)->numberOfTouches);
41400   jresult = result;
41401   return jresult;
41402 }
41403
41404
41405 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
41406   float jresult ;
41407   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41408   float result;
41409
41410   arg1 = (Dali::PanGesture *)jarg1;
41411   {
41412     try {
41413       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
41414     } catch (std::out_of_range& e) {
41415       {
41416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41417       };
41418     } catch (std::exception& e) {
41419       {
41420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41421       };
41422     } catch (Dali::DaliException e) {
41423       {
41424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41425       };
41426     } catch (...) {
41427       {
41428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41429       };
41430     }
41431   }
41432
41433   jresult = result;
41434   return jresult;
41435 }
41436
41437
41438 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
41439   float jresult ;
41440   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41441   float result;
41442
41443   arg1 = (Dali::PanGesture *)jarg1;
41444   {
41445     try {
41446       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
41447     } catch (std::out_of_range& e) {
41448       {
41449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41450       };
41451     } catch (std::exception& e) {
41452       {
41453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41454       };
41455     } catch (Dali::DaliException e) {
41456       {
41457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41458       };
41459     } catch (...) {
41460       {
41461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41462       };
41463     }
41464   }
41465
41466   jresult = result;
41467   return jresult;
41468 }
41469
41470
41471 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
41472   float jresult ;
41473   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41474   float result;
41475
41476   arg1 = (Dali::PanGesture *)jarg1;
41477   {
41478     try {
41479       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
41480     } catch (std::out_of_range& e) {
41481       {
41482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41483       };
41484     } catch (std::exception& e) {
41485       {
41486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41487       };
41488     } catch (Dali::DaliException e) {
41489       {
41490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41491       };
41492     } catch (...) {
41493       {
41494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41495       };
41496     }
41497   }
41498
41499   jresult = result;
41500   return jresult;
41501 }
41502
41503
41504 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
41505   float jresult ;
41506   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41507   float result;
41508
41509   arg1 = (Dali::PanGesture *)jarg1;
41510   {
41511     try {
41512       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
41513     } catch (std::out_of_range& e) {
41514       {
41515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41516       };
41517     } catch (std::exception& e) {
41518       {
41519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41520       };
41521     } catch (Dali::DaliException e) {
41522       {
41523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41524       };
41525     } catch (...) {
41526       {
41527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41528       };
41529     }
41530   }
41531
41532   jresult = result;
41533   return jresult;
41534 }
41535
41536
41537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
41538   void * jresult ;
41539   Dali::PinchGestureDetector *result = 0 ;
41540
41541   {
41542     try {
41543       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
41544     } catch (std::out_of_range& e) {
41545       {
41546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41547       };
41548     } catch (std::exception& e) {
41549       {
41550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41551       };
41552     } catch (Dali::DaliException e) {
41553       {
41554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41555       };
41556     } catch (...) {
41557       {
41558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41559       };
41560     }
41561   }
41562
41563   jresult = (void *)result;
41564   return jresult;
41565 }
41566
41567
41568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
41569   void * jresult ;
41570   Dali::PinchGestureDetector result;
41571
41572   {
41573     try {
41574       result = Dali::PinchGestureDetector::New();
41575     } catch (std::out_of_range& e) {
41576       {
41577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41578       };
41579     } catch (std::exception& e) {
41580       {
41581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41582       };
41583     } catch (Dali::DaliException e) {
41584       {
41585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41586       };
41587     } catch (...) {
41588       {
41589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41590       };
41591     }
41592   }
41593
41594   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41595   return jresult;
41596 }
41597
41598
41599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
41600   void * jresult ;
41601   Dali::BaseHandle arg1 ;
41602   Dali::BaseHandle *argp1 ;
41603   Dali::PinchGestureDetector result;
41604
41605   argp1 = (Dali::BaseHandle *)jarg1;
41606   if (!argp1) {
41607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41608     return 0;
41609   }
41610   arg1 = *argp1;
41611   {
41612     try {
41613       result = Dali::PinchGestureDetector::DownCast(arg1);
41614     } catch (std::out_of_range& e) {
41615       {
41616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41617       };
41618     } catch (std::exception& e) {
41619       {
41620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41621       };
41622     } catch (Dali::DaliException e) {
41623       {
41624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41625       };
41626     } catch (...) {
41627       {
41628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41629       };
41630     }
41631   }
41632
41633   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41634   return jresult;
41635 }
41636
41637
41638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41639   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41640
41641   arg1 = (Dali::PinchGestureDetector *)jarg1;
41642   {
41643     try {
41644       delete arg1;
41645     } catch (std::out_of_range& e) {
41646       {
41647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41648       };
41649     } catch (std::exception& e) {
41650       {
41651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41652       };
41653     } catch (Dali::DaliException e) {
41654       {
41655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41656       };
41657     } catch (...) {
41658       {
41659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41660       };
41661     }
41662   }
41663
41664 }
41665
41666
41667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
41668   void * jresult ;
41669   Dali::PinchGestureDetector *arg1 = 0 ;
41670   Dali::PinchGestureDetector *result = 0 ;
41671
41672   arg1 = (Dali::PinchGestureDetector *)jarg1;
41673   if (!arg1) {
41674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41675     return 0;
41676   }
41677   {
41678     try {
41679       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
41680     } catch (std::out_of_range& e) {
41681       {
41682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41683       };
41684     } catch (std::exception& e) {
41685       {
41686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41687       };
41688     } catch (Dali::DaliException e) {
41689       {
41690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41691       };
41692     } catch (...) {
41693       {
41694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41695       };
41696     }
41697   }
41698
41699   jresult = (void *)result;
41700   return jresult;
41701 }
41702
41703
41704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
41705   void * jresult ;
41706   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41707   Dali::PinchGestureDetector *arg2 = 0 ;
41708   Dali::PinchGestureDetector *result = 0 ;
41709
41710   arg1 = (Dali::PinchGestureDetector *)jarg1;
41711   arg2 = (Dali::PinchGestureDetector *)jarg2;
41712   if (!arg2) {
41713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41714     return 0;
41715   }
41716   {
41717     try {
41718       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
41719     } catch (std::out_of_range& e) {
41720       {
41721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41722       };
41723     } catch (std::exception& e) {
41724       {
41725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41726       };
41727     } catch (Dali::DaliException e) {
41728       {
41729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41730       };
41731     } catch (...) {
41732       {
41733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41734       };
41735     }
41736   }
41737
41738   jresult = (void *)result;
41739   return jresult;
41740 }
41741
41742
41743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
41744   void * jresult ;
41745   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41746   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
41747
41748   arg1 = (Dali::PinchGestureDetector *)jarg1;
41749   {
41750     try {
41751       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41752     } catch (std::out_of_range& e) {
41753       {
41754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41755       };
41756     } catch (std::exception& e) {
41757       {
41758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41759       };
41760     } catch (Dali::DaliException e) {
41761       {
41762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41763       };
41764     } catch (...) {
41765       {
41766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41767       };
41768     }
41769   }
41770
41771   jresult = (void *)result;
41772   return jresult;
41773 }
41774
41775
41776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
41777   void * jresult ;
41778   Dali::Gesture::State arg1 ;
41779   Dali::PinchGesture *result = 0 ;
41780
41781   arg1 = (Dali::Gesture::State)jarg1;
41782   {
41783     try {
41784       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
41785     } catch (std::out_of_range& e) {
41786       {
41787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41788       };
41789     } catch (std::exception& e) {
41790       {
41791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41792       };
41793     } catch (Dali::DaliException e) {
41794       {
41795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41796       };
41797     } catch (...) {
41798       {
41799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41800       };
41801     }
41802   }
41803
41804   jresult = (void *)result;
41805   return jresult;
41806 }
41807
41808
41809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
41810   void * jresult ;
41811   Dali::PinchGesture *arg1 = 0 ;
41812   Dali::PinchGesture *result = 0 ;
41813
41814   arg1 = (Dali::PinchGesture *)jarg1;
41815   if (!arg1) {
41816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41817     return 0;
41818   }
41819   {
41820     try {
41821       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
41822     } catch (std::out_of_range& e) {
41823       {
41824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41825       };
41826     } catch (std::exception& e) {
41827       {
41828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41829       };
41830     } catch (Dali::DaliException e) {
41831       {
41832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41833       };
41834     } catch (...) {
41835       {
41836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41837       };
41838     }
41839   }
41840
41841   jresult = (void *)result;
41842   return jresult;
41843 }
41844
41845
41846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
41847   void * jresult ;
41848   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41849   Dali::PinchGesture *arg2 = 0 ;
41850   Dali::PinchGesture *result = 0 ;
41851
41852   arg1 = (Dali::PinchGesture *)jarg1;
41853   arg2 = (Dali::PinchGesture *)jarg2;
41854   if (!arg2) {
41855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41856     return 0;
41857   }
41858   {
41859     try {
41860       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
41861     } catch (std::out_of_range& e) {
41862       {
41863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41864       };
41865     } catch (std::exception& e) {
41866       {
41867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41868       };
41869     } catch (Dali::DaliException e) {
41870       {
41871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41872       };
41873     } catch (...) {
41874       {
41875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41876       };
41877     }
41878   }
41879
41880   jresult = (void *)result;
41881   return jresult;
41882 }
41883
41884
41885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
41886   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41887
41888   arg1 = (Dali::PinchGesture *)jarg1;
41889   {
41890     try {
41891       delete arg1;
41892     } catch (std::out_of_range& e) {
41893       {
41894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41895       };
41896     } catch (std::exception& e) {
41897       {
41898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41899       };
41900     } catch (Dali::DaliException e) {
41901       {
41902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41903       };
41904     } catch (...) {
41905       {
41906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41907       };
41908     }
41909   }
41910
41911 }
41912
41913
41914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
41915   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41916   float arg2 ;
41917
41918   arg1 = (Dali::PinchGesture *)jarg1;
41919   arg2 = (float)jarg2;
41920   if (arg1) (arg1)->scale = arg2;
41921 }
41922
41923
41924 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
41925   float jresult ;
41926   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41927   float result;
41928
41929   arg1 = (Dali::PinchGesture *)jarg1;
41930   result = (float) ((arg1)->scale);
41931   jresult = result;
41932   return jresult;
41933 }
41934
41935
41936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
41937   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41938   float arg2 ;
41939
41940   arg1 = (Dali::PinchGesture *)jarg1;
41941   arg2 = (float)jarg2;
41942   if (arg1) (arg1)->speed = arg2;
41943 }
41944
41945
41946 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
41947   float jresult ;
41948   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41949   float result;
41950
41951   arg1 = (Dali::PinchGesture *)jarg1;
41952   result = (float) ((arg1)->speed);
41953   jresult = result;
41954   return jresult;
41955 }
41956
41957
41958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
41959   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41960   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41961
41962   arg1 = (Dali::PinchGesture *)jarg1;
41963   arg2 = (Dali::Vector2 *)jarg2;
41964   if (arg1) (arg1)->screenCenterPoint = *arg2;
41965 }
41966
41967
41968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
41969   void * jresult ;
41970   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41971   Dali::Vector2 *result = 0 ;
41972
41973   arg1 = (Dali::PinchGesture *)jarg1;
41974   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
41975   jresult = (void *)result;
41976   return jresult;
41977 }
41978
41979
41980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
41981   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41982   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41983
41984   arg1 = (Dali::PinchGesture *)jarg1;
41985   arg2 = (Dali::Vector2 *)jarg2;
41986   if (arg1) (arg1)->localCenterPoint = *arg2;
41987 }
41988
41989
41990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
41991   void * jresult ;
41992   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41993   Dali::Vector2 *result = 0 ;
41994
41995   arg1 = (Dali::PinchGesture *)jarg1;
41996   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
41997   jresult = (void *)result;
41998   return jresult;
41999 }
42000
42001
42002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
42003   void * jresult ;
42004   Dali::TapGestureDetector *result = 0 ;
42005
42006   {
42007     try {
42008       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
42009     } catch (std::out_of_range& e) {
42010       {
42011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42012       };
42013     } catch (std::exception& e) {
42014       {
42015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42016       };
42017     } catch (Dali::DaliException e) {
42018       {
42019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42020       };
42021     } catch (...) {
42022       {
42023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42024       };
42025     }
42026   }
42027
42028   jresult = (void *)result;
42029   return jresult;
42030 }
42031
42032
42033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
42034   void * jresult ;
42035   Dali::TapGestureDetector result;
42036
42037   {
42038     try {
42039       result = Dali::TapGestureDetector::New();
42040     } catch (std::out_of_range& e) {
42041       {
42042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42043       };
42044     } catch (std::exception& e) {
42045       {
42046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42047       };
42048     } catch (Dali::DaliException e) {
42049       {
42050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42051       };
42052     } catch (...) {
42053       {
42054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42055       };
42056     }
42057   }
42058
42059   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42060   return jresult;
42061 }
42062
42063
42064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
42065   void * jresult ;
42066   unsigned int arg1 ;
42067   Dali::TapGestureDetector result;
42068
42069   arg1 = (unsigned int)jarg1;
42070   {
42071     try {
42072       result = Dali::TapGestureDetector::New(arg1);
42073     } catch (std::out_of_range& e) {
42074       {
42075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42076       };
42077     } catch (std::exception& e) {
42078       {
42079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42080       };
42081     } catch (Dali::DaliException e) {
42082       {
42083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42084       };
42085     } catch (...) {
42086       {
42087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42088       };
42089     }
42090   }
42091
42092   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42093   return jresult;
42094 }
42095
42096
42097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
42098   void * jresult ;
42099   Dali::BaseHandle arg1 ;
42100   Dali::BaseHandle *argp1 ;
42101   Dali::TapGestureDetector result;
42102
42103   argp1 = (Dali::BaseHandle *)jarg1;
42104   if (!argp1) {
42105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42106     return 0;
42107   }
42108   arg1 = *argp1;
42109   {
42110     try {
42111       result = Dali::TapGestureDetector::DownCast(arg1);
42112     } catch (std::out_of_range& e) {
42113       {
42114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42115       };
42116     } catch (std::exception& e) {
42117       {
42118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42119       };
42120     } catch (Dali::DaliException e) {
42121       {
42122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42123       };
42124     } catch (...) {
42125       {
42126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42127       };
42128     }
42129   }
42130
42131   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42132   return jresult;
42133 }
42134
42135
42136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
42137   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42138
42139   arg1 = (Dali::TapGestureDetector *)jarg1;
42140   {
42141     try {
42142       delete arg1;
42143     } catch (std::out_of_range& e) {
42144       {
42145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42146       };
42147     } catch (std::exception& e) {
42148       {
42149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42150       };
42151     } catch (Dali::DaliException e) {
42152       {
42153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42154       };
42155     } catch (...) {
42156       {
42157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42158       };
42159     }
42160   }
42161
42162 }
42163
42164
42165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
42166   void * jresult ;
42167   Dali::TapGestureDetector *arg1 = 0 ;
42168   Dali::TapGestureDetector *result = 0 ;
42169
42170   arg1 = (Dali::TapGestureDetector *)jarg1;
42171   if (!arg1) {
42172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42173     return 0;
42174   }
42175   {
42176     try {
42177       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
42178     } catch (std::out_of_range& e) {
42179       {
42180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42181       };
42182     } catch (std::exception& e) {
42183       {
42184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42185       };
42186     } catch (Dali::DaliException e) {
42187       {
42188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42189       };
42190     } catch (...) {
42191       {
42192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42193       };
42194     }
42195   }
42196
42197   jresult = (void *)result;
42198   return jresult;
42199 }
42200
42201
42202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
42203   void * jresult ;
42204   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42205   Dali::TapGestureDetector *arg2 = 0 ;
42206   Dali::TapGestureDetector *result = 0 ;
42207
42208   arg1 = (Dali::TapGestureDetector *)jarg1;
42209   arg2 = (Dali::TapGestureDetector *)jarg2;
42210   if (!arg2) {
42211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42212     return 0;
42213   }
42214   {
42215     try {
42216       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
42217     } catch (std::out_of_range& e) {
42218       {
42219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42220       };
42221     } catch (std::exception& e) {
42222       {
42223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42224       };
42225     } catch (Dali::DaliException e) {
42226       {
42227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42228       };
42229     } catch (...) {
42230       {
42231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42232       };
42233     }
42234   }
42235
42236   jresult = (void *)result;
42237   return jresult;
42238 }
42239
42240
42241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
42242   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42243   unsigned int arg2 ;
42244
42245   arg1 = (Dali::TapGestureDetector *)jarg1;
42246   arg2 = (unsigned int)jarg2;
42247   {
42248     try {
42249       (arg1)->SetMinimumTapsRequired(arg2);
42250     } catch (std::out_of_range& e) {
42251       {
42252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42253       };
42254     } catch (std::exception& e) {
42255       {
42256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42257       };
42258     } catch (Dali::DaliException e) {
42259       {
42260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42261       };
42262     } catch (...) {
42263       {
42264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42265       };
42266     }
42267   }
42268
42269 }
42270
42271
42272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
42273   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42274   unsigned int arg2 ;
42275
42276   arg1 = (Dali::TapGestureDetector *)jarg1;
42277   arg2 = (unsigned int)jarg2;
42278   {
42279     try {
42280       (arg1)->SetMaximumTapsRequired(arg2);
42281     } catch (std::out_of_range& e) {
42282       {
42283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42284       };
42285     } catch (std::exception& e) {
42286       {
42287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42288       };
42289     } catch (Dali::DaliException e) {
42290       {
42291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42292       };
42293     } catch (...) {
42294       {
42295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42296       };
42297     }
42298   }
42299
42300 }
42301
42302
42303 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
42304   unsigned int jresult ;
42305   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42306   unsigned int result;
42307
42308   arg1 = (Dali::TapGestureDetector *)jarg1;
42309   {
42310     try {
42311       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
42312     } catch (std::out_of_range& e) {
42313       {
42314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42315       };
42316     } catch (std::exception& e) {
42317       {
42318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42319       };
42320     } catch (Dali::DaliException e) {
42321       {
42322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42323       };
42324     } catch (...) {
42325       {
42326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42327       };
42328     }
42329   }
42330
42331   jresult = result;
42332   return jresult;
42333 }
42334
42335
42336 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
42337   unsigned int jresult ;
42338   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42339   unsigned int result;
42340
42341   arg1 = (Dali::TapGestureDetector *)jarg1;
42342   {
42343     try {
42344       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
42345     } catch (std::out_of_range& e) {
42346       {
42347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42348       };
42349     } catch (std::exception& e) {
42350       {
42351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42352       };
42353     } catch (Dali::DaliException e) {
42354       {
42355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42356       };
42357     } catch (...) {
42358       {
42359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42360       };
42361     }
42362   }
42363
42364   jresult = result;
42365   return jresult;
42366 }
42367
42368
42369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
42370   void * jresult ;
42371   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42372   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
42373
42374   arg1 = (Dali::TapGestureDetector *)jarg1;
42375   {
42376     try {
42377       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42378     } catch (std::out_of_range& e) {
42379       {
42380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42381       };
42382     } catch (std::exception& e) {
42383       {
42384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42385       };
42386     } catch (Dali::DaliException e) {
42387       {
42388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42389       };
42390     } catch (...) {
42391       {
42392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42393       };
42394     }
42395   }
42396
42397   jresult = (void *)result;
42398   return jresult;
42399 }
42400
42401
42402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
42403   void * jresult ;
42404   Dali::TapGesture *result = 0 ;
42405
42406   {
42407     try {
42408       result = (Dali::TapGesture *)new Dali::TapGesture();
42409     } catch (std::out_of_range& e) {
42410       {
42411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42412       };
42413     } catch (std::exception& e) {
42414       {
42415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42416       };
42417     } catch (Dali::DaliException e) {
42418       {
42419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42420       };
42421     } catch (...) {
42422       {
42423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42424       };
42425     }
42426   }
42427
42428   jresult = (void *)result;
42429   return jresult;
42430 }
42431
42432
42433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
42434   void * jresult ;
42435   Dali::TapGesture *arg1 = 0 ;
42436   Dali::TapGesture *result = 0 ;
42437
42438   arg1 = (Dali::TapGesture *)jarg1;
42439   if (!arg1) {
42440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42441     return 0;
42442   }
42443   {
42444     try {
42445       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
42446     } catch (std::out_of_range& e) {
42447       {
42448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42449       };
42450     } catch (std::exception& e) {
42451       {
42452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42453       };
42454     } catch (Dali::DaliException e) {
42455       {
42456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42457       };
42458     } catch (...) {
42459       {
42460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42461       };
42462     }
42463   }
42464
42465   jresult = (void *)result;
42466   return jresult;
42467 }
42468
42469
42470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
42471   void * jresult ;
42472   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42473   Dali::TapGesture *arg2 = 0 ;
42474   Dali::TapGesture *result = 0 ;
42475
42476   arg1 = (Dali::TapGesture *)jarg1;
42477   arg2 = (Dali::TapGesture *)jarg2;
42478   if (!arg2) {
42479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42480     return 0;
42481   }
42482   {
42483     try {
42484       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
42485     } catch (std::out_of_range& e) {
42486       {
42487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42488       };
42489     } catch (std::exception& e) {
42490       {
42491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42492       };
42493     } catch (Dali::DaliException e) {
42494       {
42495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42496       };
42497     } catch (...) {
42498       {
42499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42500       };
42501     }
42502   }
42503
42504   jresult = (void *)result;
42505   return jresult;
42506 }
42507
42508
42509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
42510   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42511
42512   arg1 = (Dali::TapGesture *)jarg1;
42513   {
42514     try {
42515       delete arg1;
42516     } catch (std::out_of_range& e) {
42517       {
42518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42519       };
42520     } catch (std::exception& e) {
42521       {
42522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42523       };
42524     } catch (Dali::DaliException e) {
42525       {
42526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42527       };
42528     } catch (...) {
42529       {
42530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42531       };
42532     }
42533   }
42534
42535 }
42536
42537
42538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
42539   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42540   unsigned int arg2 ;
42541
42542   arg1 = (Dali::TapGesture *)jarg1;
42543   arg2 = (unsigned int)jarg2;
42544   if (arg1) (arg1)->numberOfTaps = arg2;
42545 }
42546
42547
42548 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
42549   unsigned int jresult ;
42550   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42551   unsigned int result;
42552
42553   arg1 = (Dali::TapGesture *)jarg1;
42554   result = (unsigned int) ((arg1)->numberOfTaps);
42555   jresult = result;
42556   return jresult;
42557 }
42558
42559
42560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
42561   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42562   unsigned int arg2 ;
42563
42564   arg1 = (Dali::TapGesture *)jarg1;
42565   arg2 = (unsigned int)jarg2;
42566   if (arg1) (arg1)->numberOfTouches = arg2;
42567 }
42568
42569
42570 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
42571   unsigned int jresult ;
42572   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42573   unsigned int result;
42574
42575   arg1 = (Dali::TapGesture *)jarg1;
42576   result = (unsigned int) ((arg1)->numberOfTouches);
42577   jresult = result;
42578   return jresult;
42579 }
42580
42581
42582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
42583   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42584   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42585
42586   arg1 = (Dali::TapGesture *)jarg1;
42587   arg2 = (Dali::Vector2 *)jarg2;
42588   if (arg1) (arg1)->screenPoint = *arg2;
42589 }
42590
42591
42592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42593   void * jresult ;
42594   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42595   Dali::Vector2 *result = 0 ;
42596
42597   arg1 = (Dali::TapGesture *)jarg1;
42598   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42599   jresult = (void *)result;
42600   return jresult;
42601 }
42602
42603
42604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42605   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42606   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42607
42608   arg1 = (Dali::TapGesture *)jarg1;
42609   arg2 = (Dali::Vector2 *)jarg2;
42610   if (arg1) (arg1)->localPoint = *arg2;
42611 }
42612
42613
42614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42615   void * jresult ;
42616   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42617   Dali::Vector2 *result = 0 ;
42618
42619   arg1 = (Dali::TapGesture *)jarg1;
42620   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42621   jresult = (void *)result;
42622   return jresult;
42623 }
42624
42625
42626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42627   void * jresult ;
42628   Dali::AlphaFunction *result = 0 ;
42629
42630   {
42631     try {
42632       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42633     } catch (std::out_of_range& e) {
42634       {
42635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42636       };
42637     } catch (std::exception& e) {
42638       {
42639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42640       };
42641     } catch (Dali::DaliException e) {
42642       {
42643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42644       };
42645     } catch (...) {
42646       {
42647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42648       };
42649     }
42650   }
42651
42652   jresult = (void *)result;
42653   return jresult;
42654 }
42655
42656
42657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
42658   void * jresult ;
42659   Dali::AlphaFunction::BuiltinFunction arg1 ;
42660   Dali::AlphaFunction *result = 0 ;
42661
42662   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
42663   {
42664     try {
42665       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42666     } catch (std::out_of_range& e) {
42667       {
42668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42669       };
42670     } catch (std::exception& e) {
42671       {
42672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42673       };
42674     } catch (Dali::DaliException e) {
42675       {
42676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42677       };
42678     } catch (...) {
42679       {
42680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42681       };
42682     }
42683   }
42684
42685   jresult = (void *)result;
42686   return jresult;
42687 }
42688
42689
42690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
42691   void * jresult ;
42692   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
42693   Dali::AlphaFunction *result = 0 ;
42694
42695   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
42696   {
42697     try {
42698       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42699     } catch (std::out_of_range& e) {
42700       {
42701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42702       };
42703     } catch (std::exception& e) {
42704       {
42705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42706       };
42707     } catch (Dali::DaliException e) {
42708       {
42709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42710       };
42711     } catch (...) {
42712       {
42713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42714       };
42715     }
42716   }
42717
42718   jresult = (void *)result;
42719   return jresult;
42720 }
42721
42722
42723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
42724   void * jresult ;
42725   Dali::Vector2 *arg1 = 0 ;
42726   Dali::Vector2 *arg2 = 0 ;
42727   Dali::AlphaFunction *result = 0 ;
42728
42729   arg1 = (Dali::Vector2 *)jarg1;
42730   if (!arg1) {
42731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42732     return 0;
42733   }
42734   arg2 = (Dali::Vector2 *)jarg2;
42735   if (!arg2) {
42736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42737     return 0;
42738   }
42739   {
42740     try {
42741       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
42742     } catch (std::out_of_range& e) {
42743       {
42744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42745       };
42746     } catch (std::exception& e) {
42747       {
42748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42749       };
42750     } catch (Dali::DaliException e) {
42751       {
42752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42753       };
42754     } catch (...) {
42755       {
42756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42757       };
42758     }
42759   }
42760
42761   jresult = (void *)result;
42762   return jresult;
42763 }
42764
42765
42766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
42767   void * jresult ;
42768   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42769   Dali::Vector4 result;
42770
42771   arg1 = (Dali::AlphaFunction *)jarg1;
42772   {
42773     try {
42774       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
42775     } catch (std::out_of_range& e) {
42776       {
42777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42778       };
42779     } catch (std::exception& e) {
42780       {
42781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42782       };
42783     } catch (Dali::DaliException e) {
42784       {
42785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42786       };
42787     } catch (...) {
42788       {
42789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42790       };
42791     }
42792   }
42793
42794   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
42795   return jresult;
42796 }
42797
42798
42799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
42800   void * jresult ;
42801   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42802   Dali::AlphaFunctionPrototype result;
42803
42804   arg1 = (Dali::AlphaFunction *)jarg1;
42805   {
42806     try {
42807       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
42808     } catch (std::out_of_range& e) {
42809       {
42810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42811       };
42812     } catch (std::exception& e) {
42813       {
42814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42815       };
42816     } catch (Dali::DaliException e) {
42817       {
42818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42819       };
42820     } catch (...) {
42821       {
42822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42823       };
42824     }
42825   }
42826
42827   jresult = (void *)result;
42828   return jresult;
42829 }
42830
42831
42832 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
42833   int jresult ;
42834   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42835   Dali::AlphaFunction::BuiltinFunction result;
42836
42837   arg1 = (Dali::AlphaFunction *)jarg1;
42838   {
42839     try {
42840       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
42841     } catch (std::out_of_range& e) {
42842       {
42843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42844       };
42845     } catch (std::exception& e) {
42846       {
42847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42848       };
42849     } catch (Dali::DaliException e) {
42850       {
42851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42852       };
42853     } catch (...) {
42854       {
42855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42856       };
42857     }
42858   }
42859
42860   jresult = (int)result;
42861   return jresult;
42862 }
42863
42864
42865 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
42866   int jresult ;
42867   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42868   Dali::AlphaFunction::Mode result;
42869
42870   arg1 = (Dali::AlphaFunction *)jarg1;
42871   {
42872     try {
42873       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
42874     } catch (std::out_of_range& e) {
42875       {
42876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42877       };
42878     } catch (std::exception& e) {
42879       {
42880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42881       };
42882     } catch (Dali::DaliException e) {
42883       {
42884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42885       };
42886     } catch (...) {
42887       {
42888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42889       };
42890     }
42891   }
42892
42893   jresult = (int)result;
42894   return jresult;
42895 }
42896
42897
42898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
42899   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42900
42901   arg1 = (Dali::AlphaFunction *)jarg1;
42902   {
42903     try {
42904       delete arg1;
42905     } catch (std::out_of_range& e) {
42906       {
42907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42908       };
42909     } catch (std::exception& e) {
42910       {
42911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42912       };
42913     } catch (Dali::DaliException e) {
42914       {
42915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42916       };
42917     } catch (...) {
42918       {
42919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42920       };
42921     }
42922   }
42923
42924 }
42925
42926
42927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
42928   void * jresult ;
42929   Dali::KeyFrames result;
42930
42931   {
42932     try {
42933       result = Dali::KeyFrames::New();
42934     } catch (std::out_of_range& e) {
42935       {
42936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42937       };
42938     } catch (std::exception& e) {
42939       {
42940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42941       };
42942     } catch (Dali::DaliException e) {
42943       {
42944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42945       };
42946     } catch (...) {
42947       {
42948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42949       };
42950     }
42951   }
42952
42953   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
42954   return jresult;
42955 }
42956
42957
42958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
42959   void * jresult ;
42960   Dali::BaseHandle arg1 ;
42961   Dali::BaseHandle *argp1 ;
42962   Dali::KeyFrames result;
42963
42964   argp1 = (Dali::BaseHandle *)jarg1;
42965   if (!argp1) {
42966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42967     return 0;
42968   }
42969   arg1 = *argp1;
42970   {
42971     try {
42972       result = Dali::KeyFrames::DownCast(arg1);
42973     } catch (std::out_of_range& e) {
42974       {
42975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42976       };
42977     } catch (std::exception& e) {
42978       {
42979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42980       };
42981     } catch (Dali::DaliException e) {
42982       {
42983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42984       };
42985     } catch (...) {
42986       {
42987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42988       };
42989     }
42990   }
42991
42992   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
42993   return jresult;
42994 }
42995
42996
42997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
42998   void * jresult ;
42999   Dali::KeyFrames *result = 0 ;
43000
43001   {
43002     try {
43003       result = (Dali::KeyFrames *)new Dali::KeyFrames();
43004     } catch (std::out_of_range& e) {
43005       {
43006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43007       };
43008     } catch (std::exception& e) {
43009       {
43010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43011       };
43012     } catch (Dali::DaliException e) {
43013       {
43014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43015       };
43016     } catch (...) {
43017       {
43018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43019       };
43020     }
43021   }
43022
43023   jresult = (void *)result;
43024   return jresult;
43025 }
43026
43027
43028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
43029   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43030
43031   arg1 = (Dali::KeyFrames *)jarg1;
43032   {
43033     try {
43034       delete arg1;
43035     } catch (std::out_of_range& e) {
43036       {
43037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43038       };
43039     } catch (std::exception& e) {
43040       {
43041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43042       };
43043     } catch (Dali::DaliException e) {
43044       {
43045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43046       };
43047     } catch (...) {
43048       {
43049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43050       };
43051     }
43052   }
43053
43054 }
43055
43056
43057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
43058   void * jresult ;
43059   Dali::KeyFrames *arg1 = 0 ;
43060   Dali::KeyFrames *result = 0 ;
43061
43062   arg1 = (Dali::KeyFrames *)jarg1;
43063   if (!arg1) {
43064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43065     return 0;
43066   }
43067   {
43068     try {
43069       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
43070     } catch (std::out_of_range& e) {
43071       {
43072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43073       };
43074     } catch (std::exception& e) {
43075       {
43076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43077       };
43078     } catch (Dali::DaliException e) {
43079       {
43080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43081       };
43082     } catch (...) {
43083       {
43084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43085       };
43086     }
43087   }
43088
43089   jresult = (void *)result;
43090   return jresult;
43091 }
43092
43093
43094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
43095   void * jresult ;
43096   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43097   Dali::KeyFrames *arg2 = 0 ;
43098   Dali::KeyFrames *result = 0 ;
43099
43100   arg1 = (Dali::KeyFrames *)jarg1;
43101   arg2 = (Dali::KeyFrames *)jarg2;
43102   if (!arg2) {
43103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43104     return 0;
43105   }
43106   {
43107     try {
43108       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
43109     } catch (std::out_of_range& e) {
43110       {
43111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43112       };
43113     } catch (std::exception& e) {
43114       {
43115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43116       };
43117     } catch (Dali::DaliException e) {
43118       {
43119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43120       };
43121     } catch (...) {
43122       {
43123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43124       };
43125     }
43126   }
43127
43128   jresult = (void *)result;
43129   return jresult;
43130 }
43131
43132
43133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
43134   int jresult ;
43135   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43136   Dali::Property::Type result;
43137
43138   arg1 = (Dali::KeyFrames *)jarg1;
43139   {
43140     try {
43141       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
43142     } catch (std::out_of_range& e) {
43143       {
43144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43145       };
43146     } catch (std::exception& e) {
43147       {
43148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43149       };
43150     } catch (Dali::DaliException e) {
43151       {
43152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43153       };
43154     } catch (...) {
43155       {
43156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43157       };
43158     }
43159   }
43160
43161   jresult = (int)result;
43162   return jresult;
43163 }
43164
43165
43166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
43167   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43168   float arg2 ;
43169   Dali::Property::Value arg3 ;
43170   Dali::Property::Value *argp3 ;
43171
43172   arg1 = (Dali::KeyFrames *)jarg1;
43173   arg2 = (float)jarg2;
43174   argp3 = (Dali::Property::Value *)jarg3;
43175   if (!argp3) {
43176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43177     return ;
43178   }
43179   arg3 = *argp3;
43180   {
43181     try {
43182       (arg1)->Add(arg2,arg3);
43183     } catch (std::out_of_range& e) {
43184       {
43185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43186       };
43187     } catch (std::exception& e) {
43188       {
43189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43190       };
43191     } catch (Dali::DaliException e) {
43192       {
43193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43194       };
43195     } catch (...) {
43196       {
43197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43198       };
43199     }
43200   }
43201
43202 }
43203
43204
43205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43206   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43207   float arg2 ;
43208   Dali::Property::Value arg3 ;
43209   Dali::AlphaFunction arg4 ;
43210   Dali::Property::Value *argp3 ;
43211   Dali::AlphaFunction *argp4 ;
43212
43213   arg1 = (Dali::KeyFrames *)jarg1;
43214   arg2 = (float)jarg2;
43215   argp3 = (Dali::Property::Value *)jarg3;
43216   if (!argp3) {
43217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43218     return ;
43219   }
43220   arg3 = *argp3;
43221   argp4 = (Dali::AlphaFunction *)jarg4;
43222   if (!argp4) {
43223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
43224     return ;
43225   }
43226   arg4 = *argp4;
43227   {
43228     try {
43229       (arg1)->Add(arg2,arg3,arg4);
43230     } catch (std::out_of_range& e) {
43231       {
43232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43233       };
43234     } catch (std::exception& e) {
43235       {
43236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43237       };
43238     } catch (Dali::DaliException e) {
43239       {
43240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43241       };
43242     } catch (...) {
43243       {
43244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43245       };
43246     }
43247   }
43248
43249 }
43250
43251
43252 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
43253   int jresult ;
43254   int result;
43255
43256   result = (int)Dali::Path::Property::POINTS;
43257   jresult = (int)result;
43258   return jresult;
43259 }
43260
43261
43262 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
43263   int jresult ;
43264   int result;
43265
43266   result = (int)Dali::Path::Property::CONTROL_POINTS;
43267   jresult = (int)result;
43268   return jresult;
43269 }
43270
43271
43272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
43273   void * jresult ;
43274   Dali::Path::Property *result = 0 ;
43275
43276   {
43277     try {
43278       result = (Dali::Path::Property *)new Dali::Path::Property();
43279     } catch (std::out_of_range& e) {
43280       {
43281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43282       };
43283     } catch (std::exception& e) {
43284       {
43285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43286       };
43287     } catch (Dali::DaliException e) {
43288       {
43289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43290       };
43291     } catch (...) {
43292       {
43293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43294       };
43295     }
43296   }
43297
43298   jresult = (void *)result;
43299   return jresult;
43300 }
43301
43302
43303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
43304   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
43305
43306   arg1 = (Dali::Path::Property *)jarg1;
43307   {
43308     try {
43309       delete arg1;
43310     } catch (std::out_of_range& e) {
43311       {
43312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43313       };
43314     } catch (std::exception& e) {
43315       {
43316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43317       };
43318     } catch (Dali::DaliException e) {
43319       {
43320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43321       };
43322     } catch (...) {
43323       {
43324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43325       };
43326     }
43327   }
43328
43329 }
43330
43331
43332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
43333   void * jresult ;
43334   Dali::Path result;
43335
43336   {
43337     try {
43338       result = Dali::Path::New();
43339     } catch (std::out_of_range& e) {
43340       {
43341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43342       };
43343     } catch (std::exception& e) {
43344       {
43345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43346       };
43347     } catch (Dali::DaliException e) {
43348       {
43349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43350       };
43351     } catch (...) {
43352       {
43353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43354       };
43355     }
43356   }
43357
43358   jresult = new Dali::Path((const Dali::Path &)result);
43359   return jresult;
43360 }
43361
43362
43363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
43364   void * jresult ;
43365   Dali::BaseHandle arg1 ;
43366   Dali::BaseHandle *argp1 ;
43367   Dali::Path result;
43368
43369   argp1 = (Dali::BaseHandle *)jarg1;
43370   if (!argp1) {
43371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43372     return 0;
43373   }
43374   arg1 = *argp1;
43375   {
43376     try {
43377       result = Dali::Path::DownCast(arg1);
43378     } catch (std::out_of_range& e) {
43379       {
43380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43381       };
43382     } catch (std::exception& e) {
43383       {
43384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43385       };
43386     } catch (Dali::DaliException e) {
43387       {
43388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43389       };
43390     } catch (...) {
43391       {
43392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43393       };
43394     }
43395   }
43396
43397   jresult = new Dali::Path((const Dali::Path &)result);
43398   return jresult;
43399 }
43400
43401
43402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
43403   void * jresult ;
43404   Dali::Path *result = 0 ;
43405
43406   {
43407     try {
43408       result = (Dali::Path *)new Dali::Path();
43409     } catch (std::out_of_range& e) {
43410       {
43411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43412       };
43413     } catch (std::exception& e) {
43414       {
43415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43416       };
43417     } catch (Dali::DaliException e) {
43418       {
43419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43420       };
43421     } catch (...) {
43422       {
43423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43424       };
43425     }
43426   }
43427
43428   jresult = (void *)result;
43429   return jresult;
43430 }
43431
43432
43433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
43434   Dali::Path *arg1 = (Dali::Path *) 0 ;
43435
43436   arg1 = (Dali::Path *)jarg1;
43437   {
43438     try {
43439       delete arg1;
43440     } catch (std::out_of_range& e) {
43441       {
43442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43443       };
43444     } catch (std::exception& e) {
43445       {
43446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43447       };
43448     } catch (Dali::DaliException e) {
43449       {
43450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43451       };
43452     } catch (...) {
43453       {
43454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43455       };
43456     }
43457   }
43458
43459 }
43460
43461
43462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
43463   void * jresult ;
43464   Dali::Path *arg1 = 0 ;
43465   Dali::Path *result = 0 ;
43466
43467   arg1 = (Dali::Path *)jarg1;
43468   if (!arg1) {
43469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43470     return 0;
43471   }
43472   {
43473     try {
43474       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
43475     } catch (std::out_of_range& e) {
43476       {
43477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43478       };
43479     } catch (std::exception& e) {
43480       {
43481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43482       };
43483     } catch (Dali::DaliException e) {
43484       {
43485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43486       };
43487     } catch (...) {
43488       {
43489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43490       };
43491     }
43492   }
43493
43494   jresult = (void *)result;
43495   return jresult;
43496 }
43497
43498
43499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
43500   void * jresult ;
43501   Dali::Path *arg1 = (Dali::Path *) 0 ;
43502   Dali::Path *arg2 = 0 ;
43503   Dali::Path *result = 0 ;
43504
43505   arg1 = (Dali::Path *)jarg1;
43506   arg2 = (Dali::Path *)jarg2;
43507   if (!arg2) {
43508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43509     return 0;
43510   }
43511   {
43512     try {
43513       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
43514     } catch (std::out_of_range& e) {
43515       {
43516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43517       };
43518     } catch (std::exception& e) {
43519       {
43520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43521       };
43522     } catch (Dali::DaliException e) {
43523       {
43524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43525       };
43526     } catch (...) {
43527       {
43528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43529       };
43530     }
43531   }
43532
43533   jresult = (void *)result;
43534   return jresult;
43535 }
43536
43537
43538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
43539   Dali::Path *arg1 = (Dali::Path *) 0 ;
43540   Dali::Vector3 *arg2 = 0 ;
43541
43542   arg1 = (Dali::Path *)jarg1;
43543   arg2 = (Dali::Vector3 *)jarg2;
43544   if (!arg2) {
43545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43546     return ;
43547   }
43548   {
43549     try {
43550       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
43551     } catch (std::out_of_range& e) {
43552       {
43553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43554       };
43555     } catch (std::exception& e) {
43556       {
43557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43558       };
43559     } catch (Dali::DaliException e) {
43560       {
43561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43562       };
43563     } catch (...) {
43564       {
43565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43566       };
43567     }
43568   }
43569
43570 }
43571
43572
43573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
43574   Dali::Path *arg1 = (Dali::Path *) 0 ;
43575   Dali::Vector3 *arg2 = 0 ;
43576
43577   arg1 = (Dali::Path *)jarg1;
43578   arg2 = (Dali::Vector3 *)jarg2;
43579   if (!arg2) {
43580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43581     return ;
43582   }
43583   {
43584     try {
43585       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
43586     } catch (std::out_of_range& e) {
43587       {
43588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43589       };
43590     } catch (std::exception& e) {
43591       {
43592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43593       };
43594     } catch (Dali::DaliException e) {
43595       {
43596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43597       };
43598     } catch (...) {
43599       {
43600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43601       };
43602     }
43603   }
43604
43605 }
43606
43607
43608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43609   Dali::Path *arg1 = (Dali::Path *) 0 ;
43610   float arg2 ;
43611
43612   arg1 = (Dali::Path *)jarg1;
43613   arg2 = (float)jarg2;
43614   {
43615     try {
43616       (arg1)->GenerateControlPoints(arg2);
43617     } catch (std::out_of_range& e) {
43618       {
43619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43620       };
43621     } catch (std::exception& e) {
43622       {
43623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43624       };
43625     } catch (Dali::DaliException e) {
43626       {
43627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43628       };
43629     } catch (...) {
43630       {
43631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43632       };
43633     }
43634   }
43635
43636 }
43637
43638
43639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43640   Dali::Path *arg1 = (Dali::Path *) 0 ;
43641   float arg2 ;
43642   Dali::Vector3 *arg3 = 0 ;
43643   Dali::Vector3 *arg4 = 0 ;
43644
43645   arg1 = (Dali::Path *)jarg1;
43646   arg2 = (float)jarg2;
43647   arg3 = (Dali::Vector3 *)jarg3;
43648   if (!arg3) {
43649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43650     return ;
43651   }
43652   arg4 = (Dali::Vector3 *)jarg4;
43653   if (!arg4) {
43654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43655     return ;
43656   }
43657   {
43658     try {
43659       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
43660     } catch (std::out_of_range& e) {
43661       {
43662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43663       };
43664     } catch (std::exception& e) {
43665       {
43666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43667       };
43668     } catch (Dali::DaliException e) {
43669       {
43670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43671       };
43672     } catch (...) {
43673       {
43674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43675       };
43676     }
43677   }
43678
43679 }
43680
43681
43682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
43683   void * jresult ;
43684   Dali::Path *arg1 = (Dali::Path *) 0 ;
43685   size_t arg2 ;
43686   Dali::Vector3 *result = 0 ;
43687
43688   arg1 = (Dali::Path *)jarg1;
43689   arg2 = (size_t)jarg2;
43690   {
43691     try {
43692       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
43693     } catch (std::out_of_range& e) {
43694       {
43695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43696       };
43697     } catch (std::exception& e) {
43698       {
43699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43700       };
43701     } catch (Dali::DaliException e) {
43702       {
43703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43704       };
43705     } catch (...) {
43706       {
43707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43708       };
43709     }
43710   }
43711
43712   jresult = (void *)result;
43713   return jresult;
43714 }
43715
43716
43717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
43718   void * jresult ;
43719   Dali::Path *arg1 = (Dali::Path *) 0 ;
43720   size_t arg2 ;
43721   Dali::Vector3 *result = 0 ;
43722
43723   arg1 = (Dali::Path *)jarg1;
43724   arg2 = (size_t)jarg2;
43725   {
43726     try {
43727       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
43728     } catch (std::out_of_range& e) {
43729       {
43730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43731       };
43732     } catch (std::exception& e) {
43733       {
43734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43735       };
43736     } catch (Dali::DaliException e) {
43737       {
43738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43739       };
43740     } catch (...) {
43741       {
43742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43743       };
43744     }
43745   }
43746
43747   jresult = (void *)result;
43748   return jresult;
43749 }
43750
43751
43752 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
43753   unsigned long jresult ;
43754   Dali::Path *arg1 = (Dali::Path *) 0 ;
43755   size_t result;
43756
43757   arg1 = (Dali::Path *)jarg1;
43758   {
43759     try {
43760       result = ((Dali::Path const *)arg1)->GetPointCount();
43761     } catch (std::out_of_range& e) {
43762       {
43763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43764       };
43765     } catch (std::exception& e) {
43766       {
43767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43768       };
43769     } catch (Dali::DaliException e) {
43770       {
43771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43772       };
43773     } catch (...) {
43774       {
43775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43776       };
43777     }
43778   }
43779
43780   jresult = (unsigned long)result;
43781   return jresult;
43782 }
43783
43784
43785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
43786   void * jresult ;
43787   float arg1 ;
43788   Dali::TimePeriod *result = 0 ;
43789
43790   arg1 = (float)jarg1;
43791   {
43792     try {
43793       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
43794     } catch (std::out_of_range& e) {
43795       {
43796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43797       };
43798     } catch (std::exception& e) {
43799       {
43800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43801       };
43802     } catch (Dali::DaliException e) {
43803       {
43804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43805       };
43806     } catch (...) {
43807       {
43808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43809       };
43810     }
43811   }
43812
43813   jresult = (void *)result;
43814   return jresult;
43815 }
43816
43817
43818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
43819   void * jresult ;
43820   float arg1 ;
43821   float arg2 ;
43822   Dali::TimePeriod *result = 0 ;
43823
43824   arg1 = (float)jarg1;
43825   arg2 = (float)jarg2;
43826   {
43827     try {
43828       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
43829     } catch (std::out_of_range& e) {
43830       {
43831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43832       };
43833     } catch (std::exception& e) {
43834       {
43835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43836       };
43837     } catch (Dali::DaliException e) {
43838       {
43839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43840       };
43841     } catch (...) {
43842       {
43843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43844       };
43845     }
43846   }
43847
43848   jresult = (void *)result;
43849   return jresult;
43850 }
43851
43852
43853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
43854   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43855
43856   arg1 = (Dali::TimePeriod *)jarg1;
43857   {
43858     try {
43859       delete arg1;
43860     } catch (std::out_of_range& e) {
43861       {
43862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43863       };
43864     } catch (std::exception& e) {
43865       {
43866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43867       };
43868     } catch (Dali::DaliException e) {
43869       {
43870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43871       };
43872     } catch (...) {
43873       {
43874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43875       };
43876     }
43877   }
43878
43879 }
43880
43881
43882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
43883   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43884   float arg2 ;
43885
43886   arg1 = (Dali::TimePeriod *)jarg1;
43887   arg2 = (float)jarg2;
43888   if (arg1) (arg1)->delaySeconds = arg2;
43889 }
43890
43891
43892 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
43893   float jresult ;
43894   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43895   float result;
43896
43897   arg1 = (Dali::TimePeriod *)jarg1;
43898   result = (float) ((arg1)->delaySeconds);
43899   jresult = result;
43900   return jresult;
43901 }
43902
43903
43904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
43905   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43906   float arg2 ;
43907
43908   arg1 = (Dali::TimePeriod *)jarg1;
43909   arg2 = (float)jarg2;
43910   if (arg1) (arg1)->durationSeconds = arg2;
43911 }
43912
43913
43914 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
43915   float jresult ;
43916   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43917   float result;
43918
43919   arg1 = (Dali::TimePeriod *)jarg1;
43920   result = (float) ((arg1)->durationSeconds);
43921   jresult = result;
43922   return jresult;
43923 }
43924
43925 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
43926   int jresult ;
43927   int result;
43928
43929   result = (int)Dali::LinearConstrainer::Property::VALUE;
43930   jresult = (int)result;
43931   return jresult;
43932 }
43933
43934
43935 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
43936   int jresult ;
43937   int result;
43938
43939   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
43940   jresult = (int)result;
43941   return jresult;
43942 }
43943
43944
43945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
43946   void * jresult ;
43947   Dali::LinearConstrainer::Property *result = 0 ;
43948
43949   {
43950     try {
43951       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
43952     } catch (std::out_of_range& e) {
43953       {
43954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43955       };
43956     } catch (std::exception& e) {
43957       {
43958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43959       };
43960     } catch (Dali::DaliException e) {
43961       {
43962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43963       };
43964     } catch (...) {
43965       {
43966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43967       };
43968     }
43969   }
43970
43971   jresult = (void *)result;
43972   return jresult;
43973 }
43974
43975
43976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
43977   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
43978
43979   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
43980   {
43981     try {
43982       delete arg1;
43983     } catch (std::out_of_range& e) {
43984       {
43985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43986       };
43987     } catch (std::exception& e) {
43988       {
43989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43990       };
43991     } catch (Dali::DaliException e) {
43992       {
43993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43994       };
43995     } catch (...) {
43996       {
43997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43998       };
43999     }
44000   }
44001
44002 }
44003
44004
44005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
44006   void * jresult ;
44007   Dali::LinearConstrainer result;
44008
44009   {
44010     try {
44011       result = Dali::LinearConstrainer::New();
44012     } catch (std::out_of_range& e) {
44013       {
44014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44015       };
44016     } catch (std::exception& e) {
44017       {
44018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44019       };
44020     } catch (Dali::DaliException e) {
44021       {
44022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44023       };
44024     } catch (...) {
44025       {
44026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44027       };
44028     }
44029   }
44030
44031   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44032   return jresult;
44033 }
44034
44035
44036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
44037   void * jresult ;
44038   Dali::BaseHandle arg1 ;
44039   Dali::BaseHandle *argp1 ;
44040   Dali::LinearConstrainer result;
44041
44042   argp1 = (Dali::BaseHandle *)jarg1;
44043   if (!argp1) {
44044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44045     return 0;
44046   }
44047   arg1 = *argp1;
44048   {
44049     try {
44050       result = Dali::LinearConstrainer::DownCast(arg1);
44051     } catch (std::out_of_range& e) {
44052       {
44053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44054       };
44055     } catch (std::exception& e) {
44056       {
44057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44058       };
44059     } catch (Dali::DaliException e) {
44060       {
44061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44062       };
44063     } catch (...) {
44064       {
44065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44066       };
44067     }
44068   }
44069
44070   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44071   return jresult;
44072 }
44073
44074
44075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
44076   void * jresult ;
44077   Dali::LinearConstrainer *result = 0 ;
44078
44079   {
44080     try {
44081       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
44082     } catch (std::out_of_range& e) {
44083       {
44084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44085       };
44086     } catch (std::exception& e) {
44087       {
44088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44089       };
44090     } catch (Dali::DaliException e) {
44091       {
44092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44093       };
44094     } catch (...) {
44095       {
44096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44097       };
44098     }
44099   }
44100
44101   jresult = (void *)result;
44102   return jresult;
44103 }
44104
44105
44106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
44107   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44108
44109   arg1 = (Dali::LinearConstrainer *)jarg1;
44110   {
44111     try {
44112       delete arg1;
44113     } catch (std::out_of_range& e) {
44114       {
44115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44116       };
44117     } catch (std::exception& e) {
44118       {
44119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44120       };
44121     } catch (Dali::DaliException e) {
44122       {
44123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44124       };
44125     } catch (...) {
44126       {
44127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44128       };
44129     }
44130   }
44131
44132 }
44133
44134
44135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
44136   void * jresult ;
44137   Dali::LinearConstrainer *arg1 = 0 ;
44138   Dali::LinearConstrainer *result = 0 ;
44139
44140   arg1 = (Dali::LinearConstrainer *)jarg1;
44141   if (!arg1) {
44142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44143     return 0;
44144   }
44145   {
44146     try {
44147       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
44148     } catch (std::out_of_range& e) {
44149       {
44150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44151       };
44152     } catch (std::exception& e) {
44153       {
44154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44155       };
44156     } catch (Dali::DaliException e) {
44157       {
44158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44159       };
44160     } catch (...) {
44161       {
44162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44163       };
44164     }
44165   }
44166
44167   jresult = (void *)result;
44168   return jresult;
44169 }
44170
44171
44172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
44173   void * jresult ;
44174   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44175   Dali::LinearConstrainer *arg2 = 0 ;
44176   Dali::LinearConstrainer *result = 0 ;
44177
44178   arg1 = (Dali::LinearConstrainer *)jarg1;
44179   arg2 = (Dali::LinearConstrainer *)jarg2;
44180   if (!arg2) {
44181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44182     return 0;
44183   }
44184   {
44185     try {
44186       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
44187     } catch (std::out_of_range& e) {
44188       {
44189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44190       };
44191     } catch (std::exception& e) {
44192       {
44193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44194       };
44195     } catch (Dali::DaliException e) {
44196       {
44197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44198       };
44199     } catch (...) {
44200       {
44201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44202       };
44203     }
44204   }
44205
44206   jresult = (void *)result;
44207   return jresult;
44208 }
44209
44210
44211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44212   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44213   SwigValueWrapper< Dali::Property > arg2 ;
44214   SwigValueWrapper< Dali::Property > arg3 ;
44215   Dali::Vector2 *arg4 = 0 ;
44216   Dali::Vector2 *arg5 = 0 ;
44217   Dali::Property *argp2 ;
44218   Dali::Property *argp3 ;
44219
44220   arg1 = (Dali::LinearConstrainer *)jarg1;
44221   argp2 = (Dali::Property *)jarg2;
44222   if (!argp2) {
44223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44224     return ;
44225   }
44226   arg2 = *argp2;
44227   argp3 = (Dali::Property *)jarg3;
44228   if (!argp3) {
44229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44230     return ;
44231   }
44232   arg3 = *argp3;
44233   arg4 = (Dali::Vector2 *)jarg4;
44234   if (!arg4) {
44235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44236     return ;
44237   }
44238   arg5 = (Dali::Vector2 *)jarg5;
44239   if (!arg5) {
44240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44241     return ;
44242   }
44243   {
44244     try {
44245       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44246     } catch (std::out_of_range& e) {
44247       {
44248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44249       };
44250     } catch (std::exception& e) {
44251       {
44252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44253       };
44254     } catch (Dali::DaliException e) {
44255       {
44256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44257       };
44258     } catch (...) {
44259       {
44260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44261       };
44262     }
44263   }
44264
44265 }
44266
44267
44268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44269   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44270   SwigValueWrapper< Dali::Property > arg2 ;
44271   SwigValueWrapper< Dali::Property > arg3 ;
44272   Dali::Vector2 *arg4 = 0 ;
44273   Dali::Property *argp2 ;
44274   Dali::Property *argp3 ;
44275
44276   arg1 = (Dali::LinearConstrainer *)jarg1;
44277   argp2 = (Dali::Property *)jarg2;
44278   if (!argp2) {
44279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44280     return ;
44281   }
44282   arg2 = *argp2;
44283   argp3 = (Dali::Property *)jarg3;
44284   if (!argp3) {
44285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44286     return ;
44287   }
44288   arg3 = *argp3;
44289   arg4 = (Dali::Vector2 *)jarg4;
44290   if (!arg4) {
44291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44292     return ;
44293   }
44294   {
44295     try {
44296       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44297     } catch (std::out_of_range& e) {
44298       {
44299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44300       };
44301     } catch (std::exception& e) {
44302       {
44303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44304       };
44305     } catch (Dali::DaliException e) {
44306       {
44307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44308       };
44309     } catch (...) {
44310       {
44311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44312       };
44313     }
44314   }
44315
44316 }
44317
44318
44319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
44320   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44321   Dali::Handle *arg2 = 0 ;
44322
44323   arg1 = (Dali::LinearConstrainer *)jarg1;
44324   arg2 = (Dali::Handle *)jarg2;
44325   if (!arg2) {
44326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44327     return ;
44328   }
44329   {
44330     try {
44331       (arg1)->Remove(*arg2);
44332     } catch (std::out_of_range& e) {
44333       {
44334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44335       };
44336     } catch (std::exception& e) {
44337       {
44338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44339       };
44340     } catch (Dali::DaliException e) {
44341       {
44342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44343       };
44344     } catch (...) {
44345       {
44346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44347       };
44348     }
44349   }
44350
44351 }
44352
44353
44354 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
44355   int jresult ;
44356   int result;
44357
44358   result = (int)Dali::PathConstrainer::Property::FORWARD;
44359   jresult = (int)result;
44360   return jresult;
44361 }
44362
44363
44364 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
44365   int jresult ;
44366   int result;
44367
44368   result = (int)Dali::PathConstrainer::Property::POINTS;
44369   jresult = (int)result;
44370   return jresult;
44371 }
44372
44373
44374 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
44375   int jresult ;
44376   int result;
44377
44378   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
44379   jresult = (int)result;
44380   return jresult;
44381 }
44382
44383
44384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
44385   void * jresult ;
44386   Dali::PathConstrainer::Property *result = 0 ;
44387
44388   {
44389     try {
44390       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
44391     } catch (std::out_of_range& e) {
44392       {
44393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44394       };
44395     } catch (std::exception& e) {
44396       {
44397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44398       };
44399     } catch (Dali::DaliException e) {
44400       {
44401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44402       };
44403     } catch (...) {
44404       {
44405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44406       };
44407     }
44408   }
44409
44410   jresult = (void *)result;
44411   return jresult;
44412 }
44413
44414
44415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
44416   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
44417
44418   arg1 = (Dali::PathConstrainer::Property *)jarg1;
44419   {
44420     try {
44421       delete arg1;
44422     } catch (std::out_of_range& e) {
44423       {
44424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44425       };
44426     } catch (std::exception& e) {
44427       {
44428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44429       };
44430     } catch (Dali::DaliException e) {
44431       {
44432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44433       };
44434     } catch (...) {
44435       {
44436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44437       };
44438     }
44439   }
44440
44441 }
44442
44443
44444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
44445   void * jresult ;
44446   Dali::PathConstrainer result;
44447
44448   {
44449     try {
44450       result = Dali::PathConstrainer::New();
44451     } catch (std::out_of_range& e) {
44452       {
44453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44454       };
44455     } catch (std::exception& e) {
44456       {
44457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44458       };
44459     } catch (Dali::DaliException e) {
44460       {
44461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44462       };
44463     } catch (...) {
44464       {
44465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44466       };
44467     }
44468   }
44469
44470   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44471   return jresult;
44472 }
44473
44474
44475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
44476   void * jresult ;
44477   Dali::BaseHandle arg1 ;
44478   Dali::BaseHandle *argp1 ;
44479   Dali::PathConstrainer result;
44480
44481   argp1 = (Dali::BaseHandle *)jarg1;
44482   if (!argp1) {
44483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44484     return 0;
44485   }
44486   arg1 = *argp1;
44487   {
44488     try {
44489       result = Dali::PathConstrainer::DownCast(arg1);
44490     } catch (std::out_of_range& e) {
44491       {
44492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44493       };
44494     } catch (std::exception& e) {
44495       {
44496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44497       };
44498     } catch (Dali::DaliException e) {
44499       {
44500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44501       };
44502     } catch (...) {
44503       {
44504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44505       };
44506     }
44507   }
44508
44509   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44510   return jresult;
44511 }
44512
44513
44514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
44515   void * jresult ;
44516   Dali::PathConstrainer *result = 0 ;
44517
44518   {
44519     try {
44520       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
44521     } catch (std::out_of_range& e) {
44522       {
44523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44524       };
44525     } catch (std::exception& e) {
44526       {
44527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44528       };
44529     } catch (Dali::DaliException e) {
44530       {
44531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44532       };
44533     } catch (...) {
44534       {
44535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44536       };
44537     }
44538   }
44539
44540   jresult = (void *)result;
44541   return jresult;
44542 }
44543
44544
44545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
44546   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44547
44548   arg1 = (Dali::PathConstrainer *)jarg1;
44549   {
44550     try {
44551       delete arg1;
44552     } catch (std::out_of_range& e) {
44553       {
44554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44555       };
44556     } catch (std::exception& e) {
44557       {
44558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44559       };
44560     } catch (Dali::DaliException e) {
44561       {
44562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44563       };
44564     } catch (...) {
44565       {
44566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44567       };
44568     }
44569   }
44570
44571 }
44572
44573
44574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
44575   void * jresult ;
44576   Dali::PathConstrainer *arg1 = 0 ;
44577   Dali::PathConstrainer *result = 0 ;
44578
44579   arg1 = (Dali::PathConstrainer *)jarg1;
44580   if (!arg1) {
44581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44582     return 0;
44583   }
44584   {
44585     try {
44586       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
44587     } catch (std::out_of_range& e) {
44588       {
44589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44590       };
44591     } catch (std::exception& e) {
44592       {
44593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44594       };
44595     } catch (Dali::DaliException e) {
44596       {
44597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44598       };
44599     } catch (...) {
44600       {
44601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44602       };
44603     }
44604   }
44605
44606   jresult = (void *)result;
44607   return jresult;
44608 }
44609
44610
44611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44612   void * jresult ;
44613   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44614   Dali::PathConstrainer *arg2 = 0 ;
44615   Dali::PathConstrainer *result = 0 ;
44616
44617   arg1 = (Dali::PathConstrainer *)jarg1;
44618   arg2 = (Dali::PathConstrainer *)jarg2;
44619   if (!arg2) {
44620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44621     return 0;
44622   }
44623   {
44624     try {
44625       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44626     } catch (std::out_of_range& e) {
44627       {
44628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44629       };
44630     } catch (std::exception& e) {
44631       {
44632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44633       };
44634     } catch (Dali::DaliException e) {
44635       {
44636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44637       };
44638     } catch (...) {
44639       {
44640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44641       };
44642     }
44643   }
44644
44645   jresult = (void *)result;
44646   return jresult;
44647 }
44648
44649
44650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44651   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44652   SwigValueWrapper< Dali::Property > arg2 ;
44653   SwigValueWrapper< Dali::Property > arg3 ;
44654   Dali::Vector2 *arg4 = 0 ;
44655   Dali::Vector2 *arg5 = 0 ;
44656   Dali::Property *argp2 ;
44657   Dali::Property *argp3 ;
44658
44659   arg1 = (Dali::PathConstrainer *)jarg1;
44660   argp2 = (Dali::Property *)jarg2;
44661   if (!argp2) {
44662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44663     return ;
44664   }
44665   arg2 = *argp2;
44666   argp3 = (Dali::Property *)jarg3;
44667   if (!argp3) {
44668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44669     return ;
44670   }
44671   arg3 = *argp3;
44672   arg4 = (Dali::Vector2 *)jarg4;
44673   if (!arg4) {
44674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44675     return ;
44676   }
44677   arg5 = (Dali::Vector2 *)jarg5;
44678   if (!arg5) {
44679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44680     return ;
44681   }
44682   {
44683     try {
44684       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44685     } catch (std::out_of_range& e) {
44686       {
44687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44688       };
44689     } catch (std::exception& e) {
44690       {
44691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44692       };
44693     } catch (Dali::DaliException e) {
44694       {
44695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44696       };
44697     } catch (...) {
44698       {
44699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44700       };
44701     }
44702   }
44703
44704 }
44705
44706
44707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44708   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44709   SwigValueWrapper< Dali::Property > arg2 ;
44710   SwigValueWrapper< Dali::Property > arg3 ;
44711   Dali::Vector2 *arg4 = 0 ;
44712   Dali::Property *argp2 ;
44713   Dali::Property *argp3 ;
44714
44715   arg1 = (Dali::PathConstrainer *)jarg1;
44716   argp2 = (Dali::Property *)jarg2;
44717   if (!argp2) {
44718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44719     return ;
44720   }
44721   arg2 = *argp2;
44722   argp3 = (Dali::Property *)jarg3;
44723   if (!argp3) {
44724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44725     return ;
44726   }
44727   arg3 = *argp3;
44728   arg4 = (Dali::Vector2 *)jarg4;
44729   if (!arg4) {
44730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44731     return ;
44732   }
44733   {
44734     try {
44735       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44736     } catch (std::out_of_range& e) {
44737       {
44738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44739       };
44740     } catch (std::exception& e) {
44741       {
44742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44743       };
44744     } catch (Dali::DaliException e) {
44745       {
44746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44747       };
44748     } catch (...) {
44749       {
44750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44751       };
44752     }
44753   }
44754
44755 }
44756
44757
44758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
44759   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44760   Dali::Handle *arg2 = 0 ;
44761
44762   arg1 = (Dali::PathConstrainer *)jarg1;
44763   arg2 = (Dali::Handle *)jarg2;
44764   if (!arg2) {
44765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44766     return ;
44767   }
44768   {
44769     try {
44770       (arg1)->Remove(*arg2);
44771     } catch (std::out_of_range& e) {
44772       {
44773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44774       };
44775     } catch (std::exception& e) {
44776       {
44777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44778       };
44779     } catch (Dali::DaliException e) {
44780       {
44781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44782       };
44783     } catch (...) {
44784       {
44785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44786       };
44787     }
44788   }
44789
44790 }
44791
44792
44793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
44794   int jresult ;
44795   Dali::FittingMode::Type result;
44796
44797   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
44798   jresult = (int)result;
44799   return jresult;
44800 }
44801
44802
44803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
44804   int jresult ;
44805   Dali::SamplingMode::Type result;
44806
44807   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
44808   jresult = (int)result;
44809   return jresult;
44810 }
44811
44812
44813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
44814   void * jresult ;
44815   Dali::BufferImage *result = 0 ;
44816
44817   {
44818     try {
44819       result = (Dali::BufferImage *)new Dali::BufferImage();
44820     } catch (std::out_of_range& e) {
44821       {
44822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44823       };
44824     } catch (std::exception& e) {
44825       {
44826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44827       };
44828     } catch (Dali::DaliException e) {
44829       {
44830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44831       };
44832     } catch (...) {
44833       {
44834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44835       };
44836     }
44837   }
44838
44839   jresult = (void *)result;
44840   return jresult;
44841 }
44842
44843
44844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
44845   void * jresult ;
44846   unsigned int arg1 ;
44847   unsigned int arg2 ;
44848   Dali::Pixel::Format arg3 ;
44849   Dali::BufferImage result;
44850
44851   arg1 = (unsigned int)jarg1;
44852   arg2 = (unsigned int)jarg2;
44853   arg3 = (Dali::Pixel::Format)jarg3;
44854   {
44855     try {
44856       result = Dali::BufferImage::New(arg1,arg2,arg3);
44857     } catch (std::out_of_range& e) {
44858       {
44859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44860       };
44861     } catch (std::exception& e) {
44862       {
44863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44864       };
44865     } catch (Dali::DaliException e) {
44866       {
44867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44868       };
44869     } catch (...) {
44870       {
44871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44872       };
44873     }
44874   }
44875
44876   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
44877   return jresult;
44878 }
44879
44880
44881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
44882   void * jresult ;
44883   unsigned int arg1 ;
44884   unsigned int arg2 ;
44885   Dali::BufferImage result;
44886
44887   arg1 = (unsigned int)jarg1;
44888   arg2 = (unsigned int)jarg2;
44889   {
44890     try {
44891       result = Dali::BufferImage::New(arg1,arg2);
44892     } catch (std::out_of_range& e) {
44893       {
44894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44895       };
44896     } catch (std::exception& e) {
44897       {
44898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44899       };
44900     } catch (Dali::DaliException e) {
44901       {
44902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44903       };
44904     } catch (...) {
44905       {
44906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44907       };
44908     }
44909   }
44910
44911   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
44912   return jresult;
44913 }
44914
44915
44916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
44917   void * jresult ;
44918   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
44919   unsigned int arg2 ;
44920   unsigned int arg3 ;
44921   Dali::Pixel::Format arg4 ;
44922   unsigned int arg5 ;
44923   Dali::BufferImage result;
44924
44925   arg1 = jarg1;
44926   arg2 = (unsigned int)jarg2;
44927   arg3 = (unsigned int)jarg3;
44928   arg4 = (Dali::Pixel::Format)jarg4;
44929   arg5 = (unsigned int)jarg5;
44930   {
44931     try {
44932       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
44933     } catch (std::out_of_range& e) {
44934       {
44935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44936       };
44937     } catch (std::exception& e) {
44938       {
44939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44940       };
44941     } catch (Dali::DaliException e) {
44942       {
44943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44944       };
44945     } catch (...) {
44946       {
44947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44948       };
44949     }
44950   }
44951
44952   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
44953
44954
44955   return jresult;
44956 }
44957
44958
44959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
44960   void * jresult ;
44961   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
44962   unsigned int arg2 ;
44963   unsigned int arg3 ;
44964   Dali::Pixel::Format arg4 ;
44965   Dali::BufferImage result;
44966
44967   arg1 = jarg1;
44968   arg2 = (unsigned int)jarg2;
44969   arg3 = (unsigned int)jarg3;
44970   arg4 = (Dali::Pixel::Format)jarg4;
44971   {
44972     try {
44973       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
44974     } catch (std::out_of_range& e) {
44975       {
44976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44977       };
44978     } catch (std::exception& e) {
44979       {
44980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44981       };
44982     } catch (Dali::DaliException e) {
44983       {
44984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44985       };
44986     } catch (...) {
44987       {
44988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44989       };
44990     }
44991   }
44992
44993   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
44994
44995
44996   return jresult;
44997 }
44998
44999
45000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
45001   void * jresult ;
45002   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45003   unsigned int arg2 ;
45004   unsigned int arg3 ;
45005   Dali::BufferImage result;
45006
45007   arg1 = jarg1;
45008   arg2 = (unsigned int)jarg2;
45009   arg3 = (unsigned int)jarg3;
45010   {
45011     try {
45012       result = Dali::BufferImage::New(arg1,arg2,arg3);
45013     } catch (std::out_of_range& e) {
45014       {
45015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45016       };
45017     } catch (std::exception& e) {
45018       {
45019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45020       };
45021     } catch (Dali::DaliException e) {
45022       {
45023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45024       };
45025     } catch (...) {
45026       {
45027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45028       };
45029     }
45030   }
45031
45032   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45033
45034
45035   return jresult;
45036 }
45037
45038
45039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
45040   void * jresult ;
45041   Dali::BaseHandle arg1 ;
45042   Dali::BaseHandle *argp1 ;
45043   Dali::BufferImage result;
45044
45045   argp1 = (Dali::BaseHandle *)jarg1;
45046   if (!argp1) {
45047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45048     return 0;
45049   }
45050   arg1 = *argp1;
45051   {
45052     try {
45053       result = Dali::BufferImage::DownCast(arg1);
45054     } catch (std::out_of_range& e) {
45055       {
45056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45057       };
45058     } catch (std::exception& e) {
45059       {
45060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45061       };
45062     } catch (Dali::DaliException e) {
45063       {
45064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45065       };
45066     } catch (...) {
45067       {
45068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45069       };
45070     }
45071   }
45072
45073   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45074   return jresult;
45075 }
45076
45077
45078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
45079   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45080
45081   arg1 = (Dali::BufferImage *)jarg1;
45082   {
45083     try {
45084       delete arg1;
45085     } catch (std::out_of_range& e) {
45086       {
45087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45088       };
45089     } catch (std::exception& e) {
45090       {
45091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45092       };
45093     } catch (Dali::DaliException e) {
45094       {
45095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45096       };
45097     } catch (...) {
45098       {
45099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45100       };
45101     }
45102   }
45103
45104 }
45105
45106
45107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
45108   void * jresult ;
45109   Dali::BufferImage *arg1 = 0 ;
45110   Dali::BufferImage *result = 0 ;
45111
45112   arg1 = (Dali::BufferImage *)jarg1;
45113   if (!arg1) {
45114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45115     return 0;
45116   }
45117   {
45118     try {
45119       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
45120     } catch (std::out_of_range& e) {
45121       {
45122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45123       };
45124     } catch (std::exception& e) {
45125       {
45126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45127       };
45128     } catch (Dali::DaliException e) {
45129       {
45130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45131       };
45132     } catch (...) {
45133       {
45134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45135       };
45136     }
45137   }
45138
45139   jresult = (void *)result;
45140   return jresult;
45141 }
45142
45143
45144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
45145   void * jresult ;
45146   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45147   Dali::BufferImage *arg2 = 0 ;
45148   Dali::BufferImage *result = 0 ;
45149
45150   arg1 = (Dali::BufferImage *)jarg1;
45151   arg2 = (Dali::BufferImage *)jarg2;
45152   if (!arg2) {
45153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45154     return 0;
45155   }
45156   {
45157     try {
45158       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
45159     } catch (std::out_of_range& e) {
45160       {
45161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45162       };
45163     } catch (std::exception& e) {
45164       {
45165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45166       };
45167     } catch (Dali::DaliException e) {
45168       {
45169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45170       };
45171     } catch (...) {
45172       {
45173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45174       };
45175     }
45176   }
45177
45178   jresult = (void *)result;
45179   return jresult;
45180 }
45181
45182
45183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
45184   void * jresult ;
45185   Dali::BufferImage result;
45186
45187   {
45188     try {
45189       result = Dali::BufferImage::WHITE();
45190     } catch (std::out_of_range& e) {
45191       {
45192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45193       };
45194     } catch (std::exception& e) {
45195       {
45196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45197       };
45198     } catch (Dali::DaliException e) {
45199       {
45200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45201       };
45202     } catch (...) {
45203       {
45204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45205       };
45206     }
45207   }
45208
45209   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45210   return jresult;
45211 }
45212
45213
45214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
45215   void * jresult ;
45216   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45217   Dali::PixelBuffer *result = 0 ;
45218
45219   arg1 = (Dali::BufferImage *)jarg1;
45220   {
45221     try {
45222       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
45223     } catch (std::out_of_range& e) {
45224       {
45225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45226       };
45227     } catch (std::exception& e) {
45228       {
45229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45230       };
45231     } catch (Dali::DaliException e) {
45232       {
45233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45234       };
45235     } catch (...) {
45236       {
45237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45238       };
45239     }
45240   }
45241
45242   jresult = (void *)result;
45243   return jresult;
45244 }
45245
45246
45247 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
45248   unsigned int jresult ;
45249   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45250   unsigned int result;
45251
45252   arg1 = (Dali::BufferImage *)jarg1;
45253   {
45254     try {
45255       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
45256     } catch (std::out_of_range& e) {
45257       {
45258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45259       };
45260     } catch (std::exception& e) {
45261       {
45262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45263       };
45264     } catch (Dali::DaliException e) {
45265       {
45266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45267       };
45268     } catch (...) {
45269       {
45270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45271       };
45272     }
45273   }
45274
45275   jresult = result;
45276   return jresult;
45277 }
45278
45279
45280 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
45281   unsigned int jresult ;
45282   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45283   unsigned int result;
45284
45285   arg1 = (Dali::BufferImage *)jarg1;
45286   {
45287     try {
45288       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
45289     } catch (std::out_of_range& e) {
45290       {
45291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45292       };
45293     } catch (std::exception& e) {
45294       {
45295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45296       };
45297     } catch (Dali::DaliException e) {
45298       {
45299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45300       };
45301     } catch (...) {
45302       {
45303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45304       };
45305     }
45306   }
45307
45308   jresult = result;
45309   return jresult;
45310 }
45311
45312
45313 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
45314   int jresult ;
45315   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45316   Dali::Pixel::Format result;
45317
45318   arg1 = (Dali::BufferImage *)jarg1;
45319   {
45320     try {
45321       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
45322     } catch (std::out_of_range& e) {
45323       {
45324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45325       };
45326     } catch (std::exception& e) {
45327       {
45328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45329       };
45330     } catch (Dali::DaliException e) {
45331       {
45332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45333       };
45334     } catch (...) {
45335       {
45336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45337       };
45338     }
45339   }
45340
45341   jresult = (int)result;
45342   return jresult;
45343 }
45344
45345
45346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
45347   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45348
45349   arg1 = (Dali::BufferImage *)jarg1;
45350   {
45351     try {
45352       (arg1)->Update();
45353     } catch (std::out_of_range& e) {
45354       {
45355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45356       };
45357     } catch (std::exception& e) {
45358       {
45359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45360       };
45361     } catch (Dali::DaliException e) {
45362       {
45363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45364       };
45365     } catch (...) {
45366       {
45367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45368       };
45369     }
45370   }
45371
45372 }
45373
45374
45375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
45376   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45377   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
45378   Dali::RectArea *argp2 ;
45379
45380   arg1 = (Dali::BufferImage *)jarg1;
45381   argp2 = (Dali::RectArea *)jarg2;
45382   if (!argp2) {
45383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
45384     return ;
45385   }
45386   arg2 = *argp2;
45387   {
45388     try {
45389       (arg1)->Update(arg2);
45390     } catch (std::out_of_range& e) {
45391       {
45392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45393       };
45394     } catch (std::exception& e) {
45395       {
45396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45397       };
45398     } catch (Dali::DaliException e) {
45399       {
45400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45401       };
45402     } catch (...) {
45403       {
45404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45405       };
45406     }
45407   }
45408
45409 }
45410
45411
45412 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
45413   unsigned int jresult ;
45414   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45415   bool result;
45416
45417   arg1 = (Dali::BufferImage *)jarg1;
45418   {
45419     try {
45420       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
45421     } catch (std::out_of_range& e) {
45422       {
45423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45424       };
45425     } catch (std::exception& e) {
45426       {
45427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45428       };
45429     } catch (Dali::DaliException e) {
45430       {
45431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45432       };
45433     } catch (...) {
45434       {
45435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45436       };
45437     }
45438   }
45439
45440   jresult = result;
45441   return jresult;
45442 }
45443
45444
45445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
45446   void * jresult ;
45447   Dali::EncodedBufferImage *result = 0 ;
45448
45449   {
45450     try {
45451       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
45452     } catch (std::out_of_range& e) {
45453       {
45454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45455       };
45456     } catch (std::exception& e) {
45457       {
45458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45459       };
45460     } catch (Dali::DaliException e) {
45461       {
45462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45463       };
45464     } catch (...) {
45465       {
45466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45467       };
45468     }
45469   }
45470
45471   jresult = (void *)result;
45472   return jresult;
45473 }
45474
45475
45476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
45477   void * jresult ;
45478   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45479   std::size_t arg2 ;
45480   Dali::EncodedBufferImage result;
45481
45482   arg1 = (uint8_t *)jarg1;
45483   arg2 = (std::size_t)jarg2;
45484   {
45485     try {
45486       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
45487     } catch (std::out_of_range& e) {
45488       {
45489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45490       };
45491     } catch (std::exception& e) {
45492       {
45493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45494       };
45495     } catch (Dali::DaliException e) {
45496       {
45497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45498       };
45499     } catch (...) {
45500       {
45501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45502       };
45503     }
45504   }
45505
45506   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45507   return jresult;
45508 }
45509
45510
45511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
45512   void * jresult ;
45513   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45514   std::size_t arg2 ;
45515   Dali::ImageDimensions arg3 ;
45516   Dali::FittingMode::Type arg4 ;
45517   Dali::SamplingMode::Type arg5 ;
45518   bool arg6 ;
45519   Dali::ImageDimensions *argp3 ;
45520   Dali::EncodedBufferImage result;
45521
45522   arg1 = (uint8_t *)jarg1;
45523   arg2 = (std::size_t)jarg2;
45524   argp3 = (Dali::ImageDimensions *)jarg3;
45525   if (!argp3) {
45526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45527     return 0;
45528   }
45529   arg3 = *argp3;
45530   arg4 = (Dali::FittingMode::Type)jarg4;
45531   arg5 = (Dali::SamplingMode::Type)jarg5;
45532   arg6 = jarg6 ? true : false;
45533   {
45534     try {
45535       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
45536     } catch (std::out_of_range& e) {
45537       {
45538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45539       };
45540     } catch (std::exception& e) {
45541       {
45542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45543       };
45544     } catch (Dali::DaliException e) {
45545       {
45546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45547       };
45548     } catch (...) {
45549       {
45550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45551       };
45552     }
45553   }
45554
45555   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45556   return jresult;
45557 }
45558
45559
45560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
45561   void * jresult ;
45562   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45563   std::size_t arg2 ;
45564   Dali::ImageDimensions arg3 ;
45565   Dali::FittingMode::Type arg4 ;
45566   Dali::SamplingMode::Type arg5 ;
45567   Dali::ImageDimensions *argp3 ;
45568   Dali::EncodedBufferImage result;
45569
45570   arg1 = (uint8_t *)jarg1;
45571   arg2 = (std::size_t)jarg2;
45572   argp3 = (Dali::ImageDimensions *)jarg3;
45573   if (!argp3) {
45574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45575     return 0;
45576   }
45577   arg3 = *argp3;
45578   arg4 = (Dali::FittingMode::Type)jarg4;
45579   arg5 = (Dali::SamplingMode::Type)jarg5;
45580   {
45581     try {
45582       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
45583     } catch (std::out_of_range& e) {
45584       {
45585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45586       };
45587     } catch (std::exception& e) {
45588       {
45589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45590       };
45591     } catch (Dali::DaliException e) {
45592       {
45593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45594       };
45595     } catch (...) {
45596       {
45597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45598       };
45599     }
45600   }
45601
45602   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45603   return jresult;
45604 }
45605
45606
45607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
45608   void * jresult ;
45609   Dali::BaseHandle arg1 ;
45610   Dali::BaseHandle *argp1 ;
45611   Dali::EncodedBufferImage result;
45612
45613   argp1 = (Dali::BaseHandle *)jarg1;
45614   if (!argp1) {
45615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45616     return 0;
45617   }
45618   arg1 = *argp1;
45619   {
45620     try {
45621       result = Dali::EncodedBufferImage::DownCast(arg1);
45622     } catch (std::out_of_range& e) {
45623       {
45624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45625       };
45626     } catch (std::exception& e) {
45627       {
45628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45629       };
45630     } catch (Dali::DaliException e) {
45631       {
45632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45633       };
45634     } catch (...) {
45635       {
45636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45637       };
45638     }
45639   }
45640
45641   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45642   return jresult;
45643 }
45644
45645
45646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
45647   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45648
45649   arg1 = (Dali::EncodedBufferImage *)jarg1;
45650   {
45651     try {
45652       delete arg1;
45653     } catch (std::out_of_range& e) {
45654       {
45655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45656       };
45657     } catch (std::exception& e) {
45658       {
45659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45660       };
45661     } catch (Dali::DaliException e) {
45662       {
45663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45664       };
45665     } catch (...) {
45666       {
45667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45668       };
45669     }
45670   }
45671
45672 }
45673
45674
45675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
45676   void * jresult ;
45677   Dali::EncodedBufferImage *arg1 = 0 ;
45678   Dali::EncodedBufferImage *result = 0 ;
45679
45680   arg1 = (Dali::EncodedBufferImage *)jarg1;
45681   if (!arg1) {
45682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45683     return 0;
45684   }
45685   {
45686     try {
45687       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
45688     } catch (std::out_of_range& e) {
45689       {
45690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45691       };
45692     } catch (std::exception& e) {
45693       {
45694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45695       };
45696     } catch (Dali::DaliException e) {
45697       {
45698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45699       };
45700     } catch (...) {
45701       {
45702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45703       };
45704     }
45705   }
45706
45707   jresult = (void *)result;
45708   return jresult;
45709 }
45710
45711
45712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
45713   void * jresult ;
45714   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45715   Dali::EncodedBufferImage *arg2 = 0 ;
45716   Dali::EncodedBufferImage *result = 0 ;
45717
45718   arg1 = (Dali::EncodedBufferImage *)jarg1;
45719   arg2 = (Dali::EncodedBufferImage *)jarg2;
45720   if (!arg2) {
45721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45722     return 0;
45723   }
45724   {
45725     try {
45726       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
45727     } catch (std::out_of_range& e) {
45728       {
45729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45730       };
45731     } catch (std::exception& e) {
45732       {
45733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45734       };
45735     } catch (Dali::DaliException e) {
45736       {
45737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45738       };
45739     } catch (...) {
45740       {
45741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45742       };
45743     }
45744   }
45745
45746   jresult = (void *)result;
45747   return jresult;
45748 }
45749
45750
45751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
45752   void * jresult ;
45753   Dali::NativeImage *result = 0 ;
45754
45755   {
45756     try {
45757       result = (Dali::NativeImage *)new Dali::NativeImage();
45758     } catch (std::out_of_range& e) {
45759       {
45760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45761       };
45762     } catch (std::exception& e) {
45763       {
45764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45765       };
45766     } catch (Dali::DaliException e) {
45767       {
45768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45769       };
45770     } catch (...) {
45771       {
45772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45773       };
45774     }
45775   }
45776
45777   jresult = (void *)result;
45778   return jresult;
45779 }
45780
45781
45782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
45783   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
45784
45785   arg1 = (Dali::NativeImage *)jarg1;
45786   {
45787     try {
45788       delete arg1;
45789     } catch (std::out_of_range& e) {
45790       {
45791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45792       };
45793     } catch (std::exception& e) {
45794       {
45795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45796       };
45797     } catch (Dali::DaliException e) {
45798       {
45799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45800       };
45801     } catch (...) {
45802       {
45803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45804       };
45805     }
45806   }
45807
45808 }
45809
45810
45811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
45812   void * jresult ;
45813   Dali::NativeImage *arg1 = 0 ;
45814   Dali::NativeImage *result = 0 ;
45815
45816   arg1 = (Dali::NativeImage *)jarg1;
45817   if (!arg1) {
45818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
45819     return 0;
45820   }
45821   {
45822     try {
45823       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
45824     } catch (std::out_of_range& e) {
45825       {
45826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45827       };
45828     } catch (std::exception& e) {
45829       {
45830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45831       };
45832     } catch (Dali::DaliException e) {
45833       {
45834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45835       };
45836     } catch (...) {
45837       {
45838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45839       };
45840     }
45841   }
45842
45843   jresult = (void *)result;
45844   return jresult;
45845 }
45846
45847
45848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
45849   void * jresult ;
45850   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
45851   Dali::NativeImage *arg2 = 0 ;
45852   Dali::NativeImage *result = 0 ;
45853
45854   arg1 = (Dali::NativeImage *)jarg1;
45855   arg2 = (Dali::NativeImage *)jarg2;
45856   if (!arg2) {
45857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
45858     return 0;
45859   }
45860   {
45861     try {
45862       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
45863     } catch (std::out_of_range& e) {
45864       {
45865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45866       };
45867     } catch (std::exception& e) {
45868       {
45869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45870       };
45871     } catch (Dali::DaliException e) {
45872       {
45873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45874       };
45875     } catch (...) {
45876       {
45877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45878       };
45879     }
45880   }
45881
45882   jresult = (void *)result;
45883   return jresult;
45884 }
45885
45886
45887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
45888   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
45889
45890   arg1 = (Dali::NativeImage *)jarg1;
45891   {
45892     try {
45893       (arg1)->CreateGlTexture();
45894     } catch (std::out_of_range& e) {
45895       {
45896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45897       };
45898     } catch (std::exception& e) {
45899       {
45900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45901       };
45902     } catch (Dali::DaliException e) {
45903       {
45904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45905       };
45906     } catch (...) {
45907       {
45908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45909       };
45910     }
45911   }
45912
45913 }
45914
45915
45916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
45917   void * jresult ;
45918   NativeImageInterface *arg1 = 0 ;
45919   Dali::NativeImage result;
45920
45921   arg1 = (NativeImageInterface *)jarg1;
45922   if (!arg1) {
45923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
45924     return 0;
45925   }
45926   {
45927     try {
45928       result = Dali::NativeImage::New(*arg1);
45929     } catch (std::out_of_range& e) {
45930       {
45931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45932       };
45933     } catch (std::exception& e) {
45934       {
45935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45936       };
45937     } catch (Dali::DaliException e) {
45938       {
45939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45940       };
45941     } catch (...) {
45942       {
45943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45944       };
45945     }
45946   }
45947
45948   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
45949   return jresult;
45950 }
45951
45952
45953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
45954   void * jresult ;
45955   Dali::BaseHandle arg1 ;
45956   Dali::BaseHandle *argp1 ;
45957   Dali::NativeImage result;
45958
45959   argp1 = (Dali::BaseHandle *)jarg1;
45960   if (!argp1) {
45961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45962     return 0;
45963   }
45964   arg1 = *argp1;
45965   {
45966     try {
45967       result = Dali::NativeImage::DownCast(arg1);
45968     } catch (std::out_of_range& e) {
45969       {
45970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45971       };
45972     } catch (std::exception& e) {
45973       {
45974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45975       };
45976     } catch (Dali::DaliException e) {
45977       {
45978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45979       };
45980     } catch (...) {
45981       {
45982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45983       };
45984     }
45985   }
45986
45987   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
45988   return jresult;
45989 }
45990
45991
45992 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
45993   char * jresult ;
45994   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
45995   char *result = 0 ;
45996
45997   arg1 = (Dali::NativeImage *)jarg1;
45998   {
45999     try {
46000       result = (char *)(arg1)->GetCustomFragmentPreFix();
46001     } catch (std::out_of_range& e) {
46002       {
46003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46004       };
46005     } catch (std::exception& e) {
46006       {
46007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46008       };
46009     } catch (Dali::DaliException e) {
46010       {
46011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46012       };
46013     } catch (...) {
46014       {
46015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46016       };
46017     }
46018   }
46019
46020   jresult = SWIG_csharp_string_callback((const char *)result);
46021   return jresult;
46022 }
46023
46024
46025 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
46026   char * jresult ;
46027   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46028   char *result = 0 ;
46029
46030   arg1 = (Dali::NativeImage *)jarg1;
46031   {
46032     try {
46033       result = (char *)(arg1)->GetCustomSamplerTypename();
46034     } catch (std::out_of_range& e) {
46035       {
46036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46037       };
46038     } catch (std::exception& e) {
46039       {
46040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46041       };
46042     } catch (Dali::DaliException e) {
46043       {
46044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46045       };
46046     } catch (...) {
46047       {
46048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46049       };
46050     }
46051   }
46052
46053   jresult = SWIG_csharp_string_callback((const char *)result);
46054   return jresult;
46055 }
46056
46057
46058 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
46059   unsigned int jresult ;
46060   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46061   bool result;
46062
46063   arg1 = (Dali::NativeImageInterface *)jarg1;
46064   {
46065     try {
46066       result = (bool)(arg1)->GlExtensionCreate();
46067     } catch (std::out_of_range& e) {
46068       {
46069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46070       };
46071     } catch (std::exception& e) {
46072       {
46073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46074       };
46075     } catch (Dali::DaliException e) {
46076       {
46077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46078       };
46079     } catch (...) {
46080       {
46081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46082       };
46083     }
46084   }
46085
46086   jresult = result;
46087   return jresult;
46088 }
46089
46090
46091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
46092   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46093
46094   arg1 = (Dali::NativeImageInterface *)jarg1;
46095   {
46096     try {
46097       (arg1)->GlExtensionDestroy();
46098     } catch (std::out_of_range& e) {
46099       {
46100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46101       };
46102     } catch (std::exception& e) {
46103       {
46104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46105       };
46106     } catch (Dali::DaliException e) {
46107       {
46108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46109       };
46110     } catch (...) {
46111       {
46112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46113       };
46114     }
46115   }
46116
46117 }
46118
46119
46120 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
46121   unsigned int jresult ;
46122   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46123   unsigned int result;
46124
46125   arg1 = (Dali::NativeImageInterface *)jarg1;
46126   {
46127     try {
46128       result = (unsigned int)(arg1)->TargetTexture();
46129     } catch (std::out_of_range& e) {
46130       {
46131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46132       };
46133     } catch (std::exception& e) {
46134       {
46135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46136       };
46137     } catch (Dali::DaliException e) {
46138       {
46139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46140       };
46141     } catch (...) {
46142       {
46143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46144       };
46145     }
46146   }
46147
46148   jresult = result;
46149   return jresult;
46150 }
46151
46152
46153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
46154   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46155
46156   arg1 = (Dali::NativeImageInterface *)jarg1;
46157   {
46158     try {
46159       (arg1)->PrepareTexture();
46160     } catch (std::out_of_range& e) {
46161       {
46162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46163       };
46164     } catch (std::exception& e) {
46165       {
46166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46167       };
46168     } catch (Dali::DaliException e) {
46169       {
46170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46171       };
46172     } catch (...) {
46173       {
46174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46175       };
46176     }
46177   }
46178
46179 }
46180
46181
46182 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
46183   unsigned int jresult ;
46184   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46185   unsigned int result;
46186
46187   arg1 = (Dali::NativeImageInterface *)jarg1;
46188   {
46189     try {
46190       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
46191     } catch (std::out_of_range& e) {
46192       {
46193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46194       };
46195     } catch (std::exception& e) {
46196       {
46197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46198       };
46199     } catch (Dali::DaliException e) {
46200       {
46201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46202       };
46203     } catch (...) {
46204       {
46205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46206       };
46207     }
46208   }
46209
46210   jresult = result;
46211   return jresult;
46212 }
46213
46214
46215 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
46216   unsigned int jresult ;
46217   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46218   unsigned int result;
46219
46220   arg1 = (Dali::NativeImageInterface *)jarg1;
46221   {
46222     try {
46223       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
46224     } catch (std::out_of_range& e) {
46225       {
46226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46227       };
46228     } catch (std::exception& e) {
46229       {
46230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46231       };
46232     } catch (Dali::DaliException e) {
46233       {
46234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46235       };
46236     } catch (...) {
46237       {
46238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46239       };
46240     }
46241   }
46242
46243   jresult = result;
46244   return jresult;
46245 }
46246
46247
46248 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
46249   unsigned int jresult ;
46250   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46251   bool result;
46252
46253   arg1 = (Dali::NativeImageInterface *)jarg1;
46254   {
46255     try {
46256       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
46257     } catch (std::out_of_range& e) {
46258       {
46259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46260       };
46261     } catch (std::exception& e) {
46262       {
46263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46264       };
46265     } catch (Dali::DaliException e) {
46266       {
46267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46268       };
46269     } catch (...) {
46270       {
46271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46272       };
46273     }
46274   }
46275
46276   jresult = result;
46277   return jresult;
46278 }
46279
46280
46281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
46282   void * jresult ;
46283   std::string *arg1 = 0 ;
46284   Dali::ImageDimensions result;
46285
46286   if (!jarg1) {
46287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46288     return 0;
46289   }
46290   std::string arg1_str(jarg1);
46291   arg1 = &arg1_str;
46292   {
46293     try {
46294       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
46295     } catch (std::out_of_range& e) {
46296       {
46297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46298       };
46299     } catch (std::exception& e) {
46300       {
46301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46302       };
46303     } catch (Dali::DaliException e) {
46304       {
46305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46306       };
46307     } catch (...) {
46308       {
46309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46310       };
46311     }
46312   }
46313
46314   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
46315
46316   //argout typemap for const std::string&
46317
46318   return jresult;
46319 }
46320
46321
46322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
46323   void * jresult ;
46324   Dali::ResourceImage *result = 0 ;
46325
46326   {
46327     try {
46328       result = (Dali::ResourceImage *)new Dali::ResourceImage();
46329     } catch (std::out_of_range& e) {
46330       {
46331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46332       };
46333     } catch (std::exception& e) {
46334       {
46335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46336       };
46337     } catch (Dali::DaliException e) {
46338       {
46339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46340       };
46341     } catch (...) {
46342       {
46343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46344       };
46345     }
46346   }
46347
46348   jresult = (void *)result;
46349   return jresult;
46350 }
46351
46352
46353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
46354   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46355
46356   arg1 = (Dali::ResourceImage *)jarg1;
46357   {
46358     try {
46359       delete arg1;
46360     } catch (std::out_of_range& e) {
46361       {
46362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46363       };
46364     } catch (std::exception& e) {
46365       {
46366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46367       };
46368     } catch (Dali::DaliException e) {
46369       {
46370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46371       };
46372     } catch (...) {
46373       {
46374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46375       };
46376     }
46377   }
46378
46379 }
46380
46381
46382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
46383   void * jresult ;
46384   Dali::ResourceImage *arg1 = 0 ;
46385   Dali::ResourceImage *result = 0 ;
46386
46387   arg1 = (Dali::ResourceImage *)jarg1;
46388   if (!arg1) {
46389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46390     return 0;
46391   }
46392   {
46393     try {
46394       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
46395     } catch (std::out_of_range& e) {
46396       {
46397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46398       };
46399     } catch (std::exception& e) {
46400       {
46401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46402       };
46403     } catch (Dali::DaliException e) {
46404       {
46405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46406       };
46407     } catch (...) {
46408       {
46409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46410       };
46411     }
46412   }
46413
46414   jresult = (void *)result;
46415   return jresult;
46416 }
46417
46418
46419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
46420   void * jresult ;
46421   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46422   Dali::ResourceImage *arg2 = 0 ;
46423   Dali::ResourceImage *result = 0 ;
46424
46425   arg1 = (Dali::ResourceImage *)jarg1;
46426   arg2 = (Dali::ResourceImage *)jarg2;
46427   if (!arg2) {
46428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46429     return 0;
46430   }
46431   {
46432     try {
46433       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
46434     } catch (std::out_of_range& e) {
46435       {
46436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46437       };
46438     } catch (std::exception& e) {
46439       {
46440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46441       };
46442     } catch (Dali::DaliException e) {
46443       {
46444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46445       };
46446     } catch (...) {
46447       {
46448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46449       };
46450     }
46451   }
46452
46453   jresult = (void *)result;
46454   return jresult;
46455 }
46456
46457
46458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
46459   void * jresult ;
46460   std::string *arg1 = 0 ;
46461   bool arg2 ;
46462   Dali::ResourceImage result;
46463
46464   if (!jarg1) {
46465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46466     return 0;
46467   }
46468   std::string arg1_str(jarg1);
46469   arg1 = &arg1_str;
46470   arg2 = jarg2 ? true : false;
46471   {
46472     try {
46473       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46474     } catch (std::out_of_range& e) {
46475       {
46476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46477       };
46478     } catch (std::exception& e) {
46479       {
46480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46481       };
46482     } catch (Dali::DaliException e) {
46483       {
46484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46485       };
46486     } catch (...) {
46487       {
46488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46489       };
46490     }
46491   }
46492
46493   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46494
46495   //argout typemap for const std::string&
46496
46497   return jresult;
46498 }
46499
46500
46501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
46502   void * jresult ;
46503   std::string *arg1 = 0 ;
46504   Dali::ResourceImage result;
46505
46506   if (!jarg1) {
46507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46508     return 0;
46509   }
46510   std::string arg1_str(jarg1);
46511   arg1 = &arg1_str;
46512   {
46513     try {
46514       result = Dali::ResourceImage::New((std::string const &)*arg1);
46515     } catch (std::out_of_range& e) {
46516       {
46517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46518       };
46519     } catch (std::exception& e) {
46520       {
46521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46522       };
46523     } catch (Dali::DaliException e) {
46524       {
46525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46526       };
46527     } catch (...) {
46528       {
46529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46530       };
46531     }
46532   }
46533
46534   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46535
46536   //argout typemap for const std::string&
46537
46538   return jresult;
46539 }
46540
46541
46542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
46543   void * jresult ;
46544   std::string *arg1 = 0 ;
46545   Dali::ImageDimensions arg2 ;
46546   Dali::FittingMode::Type arg3 ;
46547   Dali::SamplingMode::Type arg4 ;
46548   bool arg5 ;
46549   Dali::ImageDimensions *argp2 ;
46550   Dali::ResourceImage result;
46551
46552   if (!jarg1) {
46553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46554     return 0;
46555   }
46556   std::string arg1_str(jarg1);
46557   arg1 = &arg1_str;
46558   argp2 = (Dali::ImageDimensions *)jarg2;
46559   if (!argp2) {
46560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46561     return 0;
46562   }
46563   arg2 = *argp2;
46564   arg3 = (Dali::FittingMode::Type)jarg3;
46565   arg4 = (Dali::SamplingMode::Type)jarg4;
46566   arg5 = jarg5 ? true : false;
46567   {
46568     try {
46569       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
46570     } catch (std::out_of_range& e) {
46571       {
46572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46573       };
46574     } catch (std::exception& e) {
46575       {
46576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46577       };
46578     } catch (Dali::DaliException e) {
46579       {
46580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46581       };
46582     } catch (...) {
46583       {
46584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46585       };
46586     }
46587   }
46588
46589   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46590
46591   //argout typemap for const std::string&
46592
46593   return jresult;
46594 }
46595
46596
46597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
46598   void * jresult ;
46599   std::string *arg1 = 0 ;
46600   Dali::ImageDimensions arg2 ;
46601   Dali::FittingMode::Type arg3 ;
46602   Dali::SamplingMode::Type arg4 ;
46603   Dali::ImageDimensions *argp2 ;
46604   Dali::ResourceImage result;
46605
46606   if (!jarg1) {
46607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46608     return 0;
46609   }
46610   std::string arg1_str(jarg1);
46611   arg1 = &arg1_str;
46612   argp2 = (Dali::ImageDimensions *)jarg2;
46613   if (!argp2) {
46614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46615     return 0;
46616   }
46617   arg2 = *argp2;
46618   arg3 = (Dali::FittingMode::Type)jarg3;
46619   arg4 = (Dali::SamplingMode::Type)jarg4;
46620   {
46621     try {
46622       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
46623     } catch (std::out_of_range& e) {
46624       {
46625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46626       };
46627     } catch (std::exception& e) {
46628       {
46629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46630       };
46631     } catch (Dali::DaliException e) {
46632       {
46633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46634       };
46635     } catch (...) {
46636       {
46637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46638       };
46639     }
46640   }
46641
46642   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46643
46644   //argout typemap for const std::string&
46645
46646   return jresult;
46647 }
46648
46649
46650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
46651   void * jresult ;
46652   std::string *arg1 = 0 ;
46653   Dali::ImageDimensions arg2 ;
46654   Dali::FittingMode::Type arg3 ;
46655   Dali::ImageDimensions *argp2 ;
46656   Dali::ResourceImage result;
46657
46658   if (!jarg1) {
46659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46660     return 0;
46661   }
46662   std::string arg1_str(jarg1);
46663   arg1 = &arg1_str;
46664   argp2 = (Dali::ImageDimensions *)jarg2;
46665   if (!argp2) {
46666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46667     return 0;
46668   }
46669   arg2 = *argp2;
46670   arg3 = (Dali::FittingMode::Type)jarg3;
46671   {
46672     try {
46673       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
46674     } catch (std::out_of_range& e) {
46675       {
46676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46677       };
46678     } catch (std::exception& e) {
46679       {
46680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46681       };
46682     } catch (Dali::DaliException e) {
46683       {
46684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46685       };
46686     } catch (...) {
46687       {
46688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46689       };
46690     }
46691   }
46692
46693   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46694
46695   //argout typemap for const std::string&
46696
46697   return jresult;
46698 }
46699
46700
46701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
46702   void * jresult ;
46703   std::string *arg1 = 0 ;
46704   Dali::ImageDimensions arg2 ;
46705   Dali::ImageDimensions *argp2 ;
46706   Dali::ResourceImage result;
46707
46708   if (!jarg1) {
46709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46710     return 0;
46711   }
46712   std::string arg1_str(jarg1);
46713   arg1 = &arg1_str;
46714   argp2 = (Dali::ImageDimensions *)jarg2;
46715   if (!argp2) {
46716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46717     return 0;
46718   }
46719   arg2 = *argp2;
46720   {
46721     try {
46722       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46723     } catch (std::out_of_range& e) {
46724       {
46725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46726       };
46727     } catch (std::exception& e) {
46728       {
46729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46730       };
46731     } catch (Dali::DaliException e) {
46732       {
46733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46734       };
46735     } catch (...) {
46736       {
46737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46738       };
46739     }
46740   }
46741
46742   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46743
46744   //argout typemap for const std::string&
46745
46746   return jresult;
46747 }
46748
46749
46750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
46751   void * jresult ;
46752   Dali::BaseHandle arg1 ;
46753   Dali::BaseHandle *argp1 ;
46754   Dali::ResourceImage result;
46755
46756   argp1 = (Dali::BaseHandle *)jarg1;
46757   if (!argp1) {
46758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46759     return 0;
46760   }
46761   arg1 = *argp1;
46762   {
46763     try {
46764       result = Dali::ResourceImage::DownCast(arg1);
46765     } catch (std::out_of_range& e) {
46766       {
46767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46768       };
46769     } catch (std::exception& e) {
46770       {
46771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46772       };
46773     } catch (Dali::DaliException e) {
46774       {
46775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46776       };
46777     } catch (...) {
46778       {
46779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46780       };
46781     }
46782   }
46783
46784   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46785   return jresult;
46786 }
46787
46788
46789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
46790   int jresult ;
46791   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46792   Dali::LoadingState result;
46793
46794   arg1 = (Dali::ResourceImage *)jarg1;
46795   {
46796     try {
46797       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
46798     } catch (std::out_of_range& e) {
46799       {
46800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46801       };
46802     } catch (std::exception& e) {
46803       {
46804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46805       };
46806     } catch (Dali::DaliException e) {
46807       {
46808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46809       };
46810     } catch (...) {
46811       {
46812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46813       };
46814     }
46815   }
46816
46817   jresult = (int)result;
46818   return jresult;
46819 }
46820
46821
46822 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
46823   char * jresult ;
46824   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46825   std::string result;
46826
46827   arg1 = (Dali::ResourceImage *)jarg1;
46828   {
46829     try {
46830       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
46831     } catch (std::out_of_range& e) {
46832       {
46833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46834       };
46835     } catch (std::exception& e) {
46836       {
46837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46838       };
46839     } catch (Dali::DaliException e) {
46840       {
46841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46842       };
46843     } catch (...) {
46844       {
46845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46846       };
46847     }
46848   }
46849
46850   jresult = SWIG_csharp_string_callback((&result)->c_str());
46851   return jresult;
46852 }
46853
46854
46855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
46856   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46857
46858   arg1 = (Dali::ResourceImage *)jarg1;
46859   {
46860     try {
46861       (arg1)->Reload();
46862     } catch (std::out_of_range& e) {
46863       {
46864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46865       };
46866     } catch (std::exception& e) {
46867       {
46868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46869       };
46870     } catch (Dali::DaliException e) {
46871       {
46872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46873       };
46874     } catch (...) {
46875       {
46876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46877       };
46878     }
46879   }
46880
46881 }
46882
46883
46884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
46885   void * jresult ;
46886   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46887   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
46888
46889   arg1 = (Dali::ResourceImage *)jarg1;
46890   {
46891     try {
46892       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
46893     } catch (std::out_of_range& e) {
46894       {
46895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46896       };
46897     } catch (std::exception& e) {
46898       {
46899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46900       };
46901     } catch (Dali::DaliException e) {
46902       {
46903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46904       };
46905     } catch (...) {
46906       {
46907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46908       };
46909     }
46910   }
46911
46912   jresult = (void *)result;
46913   return jresult;
46914 }
46915
46916
46917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
46918   void * jresult ;
46919   Dali::FrameBufferImage *result = 0 ;
46920
46921   {
46922     try {
46923       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
46924     } catch (std::out_of_range& e) {
46925       {
46926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46927       };
46928     } catch (std::exception& e) {
46929       {
46930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46931       };
46932     } catch (Dali::DaliException e) {
46933       {
46934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46935       };
46936     } catch (...) {
46937       {
46938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46939       };
46940     }
46941   }
46942
46943   jresult = (void *)result;
46944   return jresult;
46945 }
46946
46947
46948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
46949   void * jresult ;
46950   unsigned int arg1 ;
46951   unsigned int arg2 ;
46952   Dali::Pixel::Format arg3 ;
46953   Dali::RenderBuffer::Format arg4 ;
46954   Dali::FrameBufferImage result;
46955
46956   arg1 = (unsigned int)jarg1;
46957   arg2 = (unsigned int)jarg2;
46958   arg3 = (Dali::Pixel::Format)jarg3;
46959   arg4 = (Dali::RenderBuffer::Format)jarg4;
46960   {
46961     try {
46962       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
46963     } catch (std::out_of_range& e) {
46964       {
46965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46966       };
46967     } catch (std::exception& e) {
46968       {
46969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46970       };
46971     } catch (Dali::DaliException e) {
46972       {
46973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46974       };
46975     } catch (...) {
46976       {
46977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46978       };
46979     }
46980   }
46981
46982   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
46983   return jresult;
46984 }
46985
46986
46987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
46988   void * jresult ;
46989   unsigned int arg1 ;
46990   unsigned int arg2 ;
46991   Dali::Pixel::Format arg3 ;
46992   Dali::FrameBufferImage result;
46993
46994   arg1 = (unsigned int)jarg1;
46995   arg2 = (unsigned int)jarg2;
46996   arg3 = (Dali::Pixel::Format)jarg3;
46997   {
46998     try {
46999       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
47000     } catch (std::out_of_range& e) {
47001       {
47002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47003       };
47004     } catch (std::exception& e) {
47005       {
47006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47007       };
47008     } catch (Dali::DaliException e) {
47009       {
47010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47011       };
47012     } catch (...) {
47013       {
47014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47015       };
47016     }
47017   }
47018
47019   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47020   return jresult;
47021 }
47022
47023
47024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
47025   void * jresult ;
47026   unsigned int arg1 ;
47027   unsigned int arg2 ;
47028   Dali::FrameBufferImage result;
47029
47030   arg1 = (unsigned int)jarg1;
47031   arg2 = (unsigned int)jarg2;
47032   {
47033     try {
47034       result = Dali::FrameBufferImage::New(arg1,arg2);
47035     } catch (std::out_of_range& e) {
47036       {
47037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47038       };
47039     } catch (std::exception& e) {
47040       {
47041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47042       };
47043     } catch (Dali::DaliException e) {
47044       {
47045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47046       };
47047     } catch (...) {
47048       {
47049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47050       };
47051     }
47052   }
47053
47054   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47055   return jresult;
47056 }
47057
47058
47059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
47060   void * jresult ;
47061   unsigned int arg1 ;
47062   Dali::FrameBufferImage result;
47063
47064   arg1 = (unsigned int)jarg1;
47065   {
47066     try {
47067       result = Dali::FrameBufferImage::New(arg1);
47068     } catch (std::out_of_range& e) {
47069       {
47070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47071       };
47072     } catch (std::exception& e) {
47073       {
47074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47075       };
47076     } catch (Dali::DaliException e) {
47077       {
47078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47079       };
47080     } catch (...) {
47081       {
47082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47083       };
47084     }
47085   }
47086
47087   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47088   return jresult;
47089 }
47090
47091
47092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
47093   void * jresult ;
47094   Dali::FrameBufferImage result;
47095
47096   {
47097     try {
47098       result = Dali::FrameBufferImage::New();
47099     } catch (std::out_of_range& e) {
47100       {
47101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47102       };
47103     } catch (std::exception& e) {
47104       {
47105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47106       };
47107     } catch (Dali::DaliException e) {
47108       {
47109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47110       };
47111     } catch (...) {
47112       {
47113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47114       };
47115     }
47116   }
47117
47118   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47119   return jresult;
47120 }
47121
47122
47123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
47124   void * jresult ;
47125   Dali::NativeImageInterface *arg1 = 0 ;
47126   Dali::FrameBufferImage result;
47127
47128   arg1 = (Dali::NativeImageInterface *)jarg1;
47129   if (!arg1) {
47130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
47131     return 0;
47132   }
47133   {
47134     try {
47135       result = Dali::FrameBufferImage::New(*arg1);
47136     } catch (std::out_of_range& e) {
47137       {
47138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47139       };
47140     } catch (std::exception& e) {
47141       {
47142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47143       };
47144     } catch (Dali::DaliException e) {
47145       {
47146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47147       };
47148     } catch (...) {
47149       {
47150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47151       };
47152     }
47153   }
47154
47155   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47156   return jresult;
47157 }
47158
47159
47160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
47161   void * jresult ;
47162   Dali::BaseHandle arg1 ;
47163   Dali::BaseHandle *argp1 ;
47164   Dali::FrameBufferImage result;
47165
47166   argp1 = (Dali::BaseHandle *)jarg1;
47167   if (!argp1) {
47168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47169     return 0;
47170   }
47171   arg1 = *argp1;
47172   {
47173     try {
47174       result = Dali::FrameBufferImage::DownCast(arg1);
47175     } catch (std::out_of_range& e) {
47176       {
47177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47178       };
47179     } catch (std::exception& e) {
47180       {
47181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47182       };
47183     } catch (Dali::DaliException e) {
47184       {
47185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47186       };
47187     } catch (...) {
47188       {
47189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47190       };
47191     }
47192   }
47193
47194   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47195   return jresult;
47196 }
47197
47198
47199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
47200   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47201
47202   arg1 = (Dali::FrameBufferImage *)jarg1;
47203   {
47204     try {
47205       delete arg1;
47206     } catch (std::out_of_range& e) {
47207       {
47208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47209       };
47210     } catch (std::exception& e) {
47211       {
47212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47213       };
47214     } catch (Dali::DaliException e) {
47215       {
47216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47217       };
47218     } catch (...) {
47219       {
47220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47221       };
47222     }
47223   }
47224
47225 }
47226
47227
47228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
47229   void * jresult ;
47230   Dali::FrameBufferImage *arg1 = 0 ;
47231   Dali::FrameBufferImage *result = 0 ;
47232
47233   arg1 = (Dali::FrameBufferImage *)jarg1;
47234   if (!arg1) {
47235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47236     return 0;
47237   }
47238   {
47239     try {
47240       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
47241     } catch (std::out_of_range& e) {
47242       {
47243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47244       };
47245     } catch (std::exception& e) {
47246       {
47247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47248       };
47249     } catch (Dali::DaliException e) {
47250       {
47251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47252       };
47253     } catch (...) {
47254       {
47255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47256       };
47257     }
47258   }
47259
47260   jresult = (void *)result;
47261   return jresult;
47262 }
47263
47264
47265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
47266   void * jresult ;
47267   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47268   Dali::FrameBufferImage *arg2 = 0 ;
47269   Dali::FrameBufferImage *result = 0 ;
47270
47271   arg1 = (Dali::FrameBufferImage *)jarg1;
47272   arg2 = (Dali::FrameBufferImage *)jarg2;
47273   if (!arg2) {
47274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47275     return 0;
47276   }
47277   {
47278     try {
47279       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
47280     } catch (std::out_of_range& e) {
47281       {
47282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47283       };
47284     } catch (std::exception& e) {
47285       {
47286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47287       };
47288     } catch (Dali::DaliException e) {
47289       {
47290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47291       };
47292     } catch (...) {
47293       {
47294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47295       };
47296     }
47297   }
47298
47299   jresult = (void *)result;
47300   return jresult;
47301 }
47302
47303
47304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
47305   void * jresult ;
47306   Dali::NinePatchImage *result = 0 ;
47307
47308   {
47309     try {
47310       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
47311     } catch (std::out_of_range& e) {
47312       {
47313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47314       };
47315     } catch (std::exception& e) {
47316       {
47317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47318       };
47319     } catch (Dali::DaliException e) {
47320       {
47321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47322       };
47323     } catch (...) {
47324       {
47325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47326       };
47327     }
47328   }
47329
47330   jresult = (void *)result;
47331   return jresult;
47332 }
47333
47334
47335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
47336   void * jresult ;
47337   std::string *arg1 = 0 ;
47338   Dali::NinePatchImage result;
47339
47340   if (!jarg1) {
47341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47342     return 0;
47343   }
47344   std::string arg1_str(jarg1);
47345   arg1 = &arg1_str;
47346   {
47347     try {
47348       result = Dali::NinePatchImage::New((std::string const &)*arg1);
47349     } catch (std::out_of_range& e) {
47350       {
47351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47352       };
47353     } catch (std::exception& e) {
47354       {
47355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47356       };
47357     } catch (Dali::DaliException e) {
47358       {
47359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47360       };
47361     } catch (...) {
47362       {
47363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47364       };
47365     }
47366   }
47367
47368   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47369
47370   //argout typemap for const std::string&
47371
47372   return jresult;
47373 }
47374
47375
47376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
47377   void * jresult ;
47378   Dali::BaseHandle arg1 ;
47379   Dali::BaseHandle *argp1 ;
47380   Dali::NinePatchImage result;
47381
47382   argp1 = (Dali::BaseHandle *)jarg1;
47383   if (!argp1) {
47384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47385     return 0;
47386   }
47387   arg1 = *argp1;
47388   {
47389     try {
47390       result = Dali::NinePatchImage::DownCast(arg1);
47391     } catch (std::out_of_range& e) {
47392       {
47393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47394       };
47395     } catch (std::exception& e) {
47396       {
47397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47398       };
47399     } catch (Dali::DaliException e) {
47400       {
47401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47402       };
47403     } catch (...) {
47404       {
47405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47406       };
47407     }
47408   }
47409
47410   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47411   return jresult;
47412 }
47413
47414
47415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
47416   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47417
47418   arg1 = (Dali::NinePatchImage *)jarg1;
47419   {
47420     try {
47421       delete arg1;
47422     } catch (std::out_of_range& e) {
47423       {
47424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47425       };
47426     } catch (std::exception& e) {
47427       {
47428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47429       };
47430     } catch (Dali::DaliException e) {
47431       {
47432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47433       };
47434     } catch (...) {
47435       {
47436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47437       };
47438     }
47439   }
47440
47441 }
47442
47443
47444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
47445   void * jresult ;
47446   Dali::NinePatchImage *arg1 = 0 ;
47447   Dali::NinePatchImage *result = 0 ;
47448
47449   arg1 = (Dali::NinePatchImage *)jarg1;
47450   if (!arg1) {
47451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47452     return 0;
47453   }
47454   {
47455     try {
47456       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
47457     } catch (std::out_of_range& e) {
47458       {
47459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47460       };
47461     } catch (std::exception& e) {
47462       {
47463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47464       };
47465     } catch (Dali::DaliException e) {
47466       {
47467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47468       };
47469     } catch (...) {
47470       {
47471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47472       };
47473     }
47474   }
47475
47476   jresult = (void *)result;
47477   return jresult;
47478 }
47479
47480
47481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
47482   void * jresult ;
47483   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47484   Dali::NinePatchImage *arg2 = 0 ;
47485   Dali::NinePatchImage *result = 0 ;
47486
47487   arg1 = (Dali::NinePatchImage *)jarg1;
47488   arg2 = (Dali::NinePatchImage *)jarg2;
47489   if (!arg2) {
47490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47491     return 0;
47492   }
47493   {
47494     try {
47495       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
47496     } catch (std::out_of_range& e) {
47497       {
47498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47499       };
47500     } catch (std::exception& e) {
47501       {
47502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47503       };
47504     } catch (Dali::DaliException e) {
47505       {
47506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47507       };
47508     } catch (...) {
47509       {
47510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47511       };
47512     }
47513   }
47514
47515   jresult = (void *)result;
47516   return jresult;
47517 }
47518
47519
47520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
47521   void * jresult ;
47522   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47523   Dali::Vector4 result;
47524
47525   arg1 = (Dali::NinePatchImage *)jarg1;
47526   {
47527     try {
47528       result = (arg1)->GetStretchBorders();
47529     } catch (std::out_of_range& e) {
47530       {
47531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47532       };
47533     } catch (std::exception& e) {
47534       {
47535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47536       };
47537     } catch (Dali::DaliException e) {
47538       {
47539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47540       };
47541     } catch (...) {
47542       {
47543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47544       };
47545     }
47546   }
47547
47548   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
47549   return jresult;
47550 }
47551
47552
47553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
47554   void * jresult ;
47555   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47556   Dali::NinePatchImage::StretchRanges *result = 0 ;
47557
47558   arg1 = (Dali::NinePatchImage *)jarg1;
47559   {
47560     try {
47561       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
47562     } catch (std::out_of_range& e) {
47563       {
47564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47565       };
47566     } catch (std::exception& e) {
47567       {
47568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47569       };
47570     } catch (Dali::DaliException e) {
47571       {
47572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47573       };
47574     } catch (...) {
47575       {
47576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47577       };
47578     }
47579   }
47580
47581   jresult = (void *)result;
47582   return jresult;
47583 }
47584
47585
47586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
47587   void * jresult ;
47588   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47589   Dali::NinePatchImage::StretchRanges *result = 0 ;
47590
47591   arg1 = (Dali::NinePatchImage *)jarg1;
47592   {
47593     try {
47594       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
47595     } catch (std::out_of_range& e) {
47596       {
47597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47598       };
47599     } catch (std::exception& e) {
47600       {
47601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47602       };
47603     } catch (Dali::DaliException e) {
47604       {
47605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47606       };
47607     } catch (...) {
47608       {
47609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47610       };
47611     }
47612   }
47613
47614   jresult = (void *)result;
47615   return jresult;
47616 }
47617
47618
47619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
47620   void * jresult ;
47621   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47622   Dali::Rect< int > result;
47623
47624   arg1 = (Dali::NinePatchImage *)jarg1;
47625   {
47626     try {
47627       result = (arg1)->GetChildRectangle();
47628     } catch (std::out_of_range& e) {
47629       {
47630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47631       };
47632     } catch (std::exception& e) {
47633       {
47634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47635       };
47636     } catch (Dali::DaliException e) {
47637       {
47638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47639       };
47640     } catch (...) {
47641       {
47642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47643       };
47644     }
47645   }
47646
47647   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
47648   return jresult;
47649 }
47650
47651
47652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
47653   void * jresult ;
47654   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47655   Dali::BufferImage result;
47656
47657   arg1 = (Dali::NinePatchImage *)jarg1;
47658   {
47659     try {
47660       result = (arg1)->CreateCroppedBufferImage();
47661     } catch (std::out_of_range& e) {
47662       {
47663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47664       };
47665     } catch (std::exception& e) {
47666       {
47667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47668       };
47669     } catch (Dali::DaliException e) {
47670       {
47671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47672       };
47673     } catch (...) {
47674       {
47675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47676       };
47677     }
47678   }
47679
47680   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
47681   return jresult;
47682 }
47683
47684
47685 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
47686   unsigned int jresult ;
47687   std::string *arg1 = 0 ;
47688   bool result;
47689
47690   if (!jarg1) {
47691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47692     return 0;
47693   }
47694   std::string arg1_str(jarg1);
47695   arg1 = &arg1_str;
47696   {
47697     try {
47698       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
47699     } catch (std::out_of_range& e) {
47700       {
47701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47702       };
47703     } catch (std::exception& e) {
47704       {
47705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47706       };
47707     } catch (Dali::DaliException e) {
47708       {
47709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47710       };
47711     } catch (...) {
47712       {
47713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47714       };
47715     }
47716   }
47717
47718   jresult = result;
47719
47720   //argout typemap for const std::string&
47721
47722   return jresult;
47723 }
47724
47725
47726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
47727   int jresult ;
47728   int result;
47729
47730   result = (int)Dali::CameraActor::Property::TYPE;
47731   jresult = (int)result;
47732   return jresult;
47733 }
47734
47735
47736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
47737   int jresult ;
47738   int result;
47739
47740   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
47741   jresult = (int)result;
47742   return jresult;
47743 }
47744
47745
47746 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
47747   int jresult ;
47748   int result;
47749
47750   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
47751   jresult = (int)result;
47752   return jresult;
47753 }
47754
47755
47756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
47757   int jresult ;
47758   int result;
47759
47760   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
47761   jresult = (int)result;
47762   return jresult;
47763 }
47764
47765
47766 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
47767   int jresult ;
47768   int result;
47769
47770   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
47771   jresult = (int)result;
47772   return jresult;
47773 }
47774
47775
47776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
47777   int jresult ;
47778   int result;
47779
47780   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
47781   jresult = (int)result;
47782   return jresult;
47783 }
47784
47785
47786 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
47787   int jresult ;
47788   int result;
47789
47790   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
47791   jresult = (int)result;
47792   return jresult;
47793 }
47794
47795
47796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
47797   int jresult ;
47798   int result;
47799
47800   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
47801   jresult = (int)result;
47802   return jresult;
47803 }
47804
47805
47806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
47807   int jresult ;
47808   int result;
47809
47810   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
47811   jresult = (int)result;
47812   return jresult;
47813 }
47814
47815
47816 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
47817   int jresult ;
47818   int result;
47819
47820   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
47821   jresult = (int)result;
47822   return jresult;
47823 }
47824
47825
47826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
47827   int jresult ;
47828   int result;
47829
47830   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
47831   jresult = (int)result;
47832   return jresult;
47833 }
47834
47835
47836 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
47837   int jresult ;
47838   int result;
47839
47840   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
47841   jresult = (int)result;
47842   return jresult;
47843 }
47844
47845
47846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
47847   int jresult ;
47848   int result;
47849
47850   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
47851   jresult = (int)result;
47852   return jresult;
47853 }
47854
47855
47856 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
47857   int jresult ;
47858   int result;
47859
47860   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
47861   jresult = (int)result;
47862   return jresult;
47863 }
47864
47865
47866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
47867   void * jresult ;
47868   Dali::CameraActor::Property *result = 0 ;
47869
47870   {
47871     try {
47872       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
47873     } catch (std::out_of_range& e) {
47874       {
47875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47876       };
47877     } catch (std::exception& e) {
47878       {
47879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47880       };
47881     } catch (Dali::DaliException e) {
47882       {
47883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47884       };
47885     } catch (...) {
47886       {
47887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47888       };
47889     }
47890   }
47891
47892   jresult = (void *)result;
47893   return jresult;
47894 }
47895
47896
47897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
47898   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
47899
47900   arg1 = (Dali::CameraActor::Property *)jarg1;
47901   {
47902     try {
47903       delete arg1;
47904     } catch (std::out_of_range& e) {
47905       {
47906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47907       };
47908     } catch (std::exception& e) {
47909       {
47910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47911       };
47912     } catch (Dali::DaliException e) {
47913       {
47914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47915       };
47916     } catch (...) {
47917       {
47918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47919       };
47920     }
47921   }
47922
47923 }
47924
47925
47926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
47927   void * jresult ;
47928   Dali::CameraActor *result = 0 ;
47929
47930   {
47931     try {
47932       result = (Dali::CameraActor *)new Dali::CameraActor();
47933     } catch (std::out_of_range& e) {
47934       {
47935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47936       };
47937     } catch (std::exception& e) {
47938       {
47939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47940       };
47941     } catch (Dali::DaliException e) {
47942       {
47943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47944       };
47945     } catch (...) {
47946       {
47947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47948       };
47949     }
47950   }
47951
47952   jresult = (void *)result;
47953   return jresult;
47954 }
47955
47956
47957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
47958   void * jresult ;
47959   Dali::CameraActor result;
47960
47961   {
47962     try {
47963       result = Dali::CameraActor::New();
47964     } catch (std::out_of_range& e) {
47965       {
47966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47967       };
47968     } catch (std::exception& e) {
47969       {
47970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47971       };
47972     } catch (Dali::DaliException e) {
47973       {
47974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47975       };
47976     } catch (...) {
47977       {
47978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47979       };
47980     }
47981   }
47982
47983   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
47984   return jresult;
47985 }
47986
47987
47988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
47989   void * jresult ;
47990   Dali::Size *arg1 = 0 ;
47991   Dali::CameraActor result;
47992
47993   arg1 = (Dali::Size *)jarg1;
47994   if (!arg1) {
47995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
47996     return 0;
47997   }
47998   {
47999     try {
48000       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
48001     } catch (std::out_of_range& e) {
48002       {
48003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48004       };
48005     } catch (std::exception& e) {
48006       {
48007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48008       };
48009     } catch (Dali::DaliException e) {
48010       {
48011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48012       };
48013     } catch (...) {
48014       {
48015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48016       };
48017     }
48018   }
48019
48020   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48021   return jresult;
48022 }
48023
48024
48025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
48026   void * jresult ;
48027   Dali::BaseHandle arg1 ;
48028   Dali::BaseHandle *argp1 ;
48029   Dali::CameraActor result;
48030
48031   argp1 = (Dali::BaseHandle *)jarg1;
48032   if (!argp1) {
48033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48034     return 0;
48035   }
48036   arg1 = *argp1;
48037   {
48038     try {
48039       result = Dali::CameraActor::DownCast(arg1);
48040     } catch (std::out_of_range& e) {
48041       {
48042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48043       };
48044     } catch (std::exception& e) {
48045       {
48046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48047       };
48048     } catch (Dali::DaliException e) {
48049       {
48050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48051       };
48052     } catch (...) {
48053       {
48054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48055       };
48056     }
48057   }
48058
48059   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48060   return jresult;
48061 }
48062
48063
48064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
48065   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48066
48067   arg1 = (Dali::CameraActor *)jarg1;
48068   {
48069     try {
48070       delete arg1;
48071     } catch (std::out_of_range& e) {
48072       {
48073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48074       };
48075     } catch (std::exception& e) {
48076       {
48077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48078       };
48079     } catch (Dali::DaliException e) {
48080       {
48081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48082       };
48083     } catch (...) {
48084       {
48085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48086       };
48087     }
48088   }
48089
48090 }
48091
48092
48093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
48094   void * jresult ;
48095   Dali::CameraActor *arg1 = 0 ;
48096   Dali::CameraActor *result = 0 ;
48097
48098   arg1 = (Dali::CameraActor *)jarg1;
48099   if (!arg1) {
48100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48101     return 0;
48102   }
48103   {
48104     try {
48105       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
48106     } catch (std::out_of_range& e) {
48107       {
48108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48109       };
48110     } catch (std::exception& e) {
48111       {
48112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48113       };
48114     } catch (Dali::DaliException e) {
48115       {
48116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48117       };
48118     } catch (...) {
48119       {
48120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48121       };
48122     }
48123   }
48124
48125   jresult = (void *)result;
48126   return jresult;
48127 }
48128
48129
48130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
48131   void * jresult ;
48132   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48133   Dali::CameraActor *arg2 = 0 ;
48134   Dali::CameraActor *result = 0 ;
48135
48136   arg1 = (Dali::CameraActor *)jarg1;
48137   arg2 = (Dali::CameraActor *)jarg2;
48138   if (!arg2) {
48139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48140     return 0;
48141   }
48142   {
48143     try {
48144       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
48145     } catch (std::out_of_range& e) {
48146       {
48147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48148       };
48149     } catch (std::exception& e) {
48150       {
48151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48152       };
48153     } catch (Dali::DaliException e) {
48154       {
48155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48156       };
48157     } catch (...) {
48158       {
48159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48160       };
48161     }
48162   }
48163
48164   jresult = (void *)result;
48165   return jresult;
48166 }
48167
48168
48169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
48170   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48171   Dali::Camera::Type arg2 ;
48172
48173   arg1 = (Dali::CameraActor *)jarg1;
48174   arg2 = (Dali::Camera::Type)jarg2;
48175   {
48176     try {
48177       (arg1)->SetType(arg2);
48178     } catch (std::out_of_range& e) {
48179       {
48180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48181       };
48182     } catch (std::exception& e) {
48183       {
48184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48185       };
48186     } catch (Dali::DaliException e) {
48187       {
48188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48189       };
48190     } catch (...) {
48191       {
48192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48193       };
48194     }
48195   }
48196
48197 }
48198
48199
48200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
48201   int jresult ;
48202   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48203   Dali::Camera::Type result;
48204
48205   arg1 = (Dali::CameraActor *)jarg1;
48206   {
48207     try {
48208       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
48209     } catch (std::out_of_range& e) {
48210       {
48211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48212       };
48213     } catch (std::exception& e) {
48214       {
48215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48216       };
48217     } catch (Dali::DaliException e) {
48218       {
48219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48220       };
48221     } catch (...) {
48222       {
48223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48224       };
48225     }
48226   }
48227
48228   jresult = (int)result;
48229   return jresult;
48230 }
48231
48232
48233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
48234   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48235   Dali::Camera::ProjectionMode arg2 ;
48236
48237   arg1 = (Dali::CameraActor *)jarg1;
48238   arg2 = (Dali::Camera::ProjectionMode)jarg2;
48239   {
48240     try {
48241       (arg1)->SetProjectionMode(arg2);
48242     } catch (std::out_of_range& e) {
48243       {
48244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48245       };
48246     } catch (std::exception& e) {
48247       {
48248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48249       };
48250     } catch (Dali::DaliException e) {
48251       {
48252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48253       };
48254     } catch (...) {
48255       {
48256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48257       };
48258     }
48259   }
48260
48261 }
48262
48263
48264 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
48265   int jresult ;
48266   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48267   Dali::Camera::ProjectionMode result;
48268
48269   arg1 = (Dali::CameraActor *)jarg1;
48270   {
48271     try {
48272       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
48273     } catch (std::out_of_range& e) {
48274       {
48275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48276       };
48277     } catch (std::exception& e) {
48278       {
48279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48280       };
48281     } catch (Dali::DaliException e) {
48282       {
48283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48284       };
48285     } catch (...) {
48286       {
48287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48288       };
48289     }
48290   }
48291
48292   jresult = (int)result;
48293   return jresult;
48294 }
48295
48296
48297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
48298   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48299   float arg2 ;
48300
48301   arg1 = (Dali::CameraActor *)jarg1;
48302   arg2 = (float)jarg2;
48303   {
48304     try {
48305       (arg1)->SetFieldOfView(arg2);
48306     } catch (std::out_of_range& e) {
48307       {
48308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48309       };
48310     } catch (std::exception& e) {
48311       {
48312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48313       };
48314     } catch (Dali::DaliException e) {
48315       {
48316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48317       };
48318     } catch (...) {
48319       {
48320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48321       };
48322     }
48323   }
48324
48325 }
48326
48327
48328 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
48329   float jresult ;
48330   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48331   float result;
48332
48333   arg1 = (Dali::CameraActor *)jarg1;
48334   {
48335     try {
48336       result = (float)(arg1)->GetFieldOfView();
48337     } catch (std::out_of_range& e) {
48338       {
48339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48340       };
48341     } catch (std::exception& e) {
48342       {
48343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48344       };
48345     } catch (Dali::DaliException e) {
48346       {
48347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48348       };
48349     } catch (...) {
48350       {
48351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48352       };
48353     }
48354   }
48355
48356   jresult = result;
48357   return jresult;
48358 }
48359
48360
48361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
48362   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48363   float arg2 ;
48364
48365   arg1 = (Dali::CameraActor *)jarg1;
48366   arg2 = (float)jarg2;
48367   {
48368     try {
48369       (arg1)->SetAspectRatio(arg2);
48370     } catch (std::out_of_range& e) {
48371       {
48372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48373       };
48374     } catch (std::exception& e) {
48375       {
48376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48377       };
48378     } catch (Dali::DaliException e) {
48379       {
48380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48381       };
48382     } catch (...) {
48383       {
48384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48385       };
48386     }
48387   }
48388
48389 }
48390
48391
48392 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
48393   float jresult ;
48394   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48395   float result;
48396
48397   arg1 = (Dali::CameraActor *)jarg1;
48398   {
48399     try {
48400       result = (float)(arg1)->GetAspectRatio();
48401     } catch (std::out_of_range& e) {
48402       {
48403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48404       };
48405     } catch (std::exception& e) {
48406       {
48407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48408       };
48409     } catch (Dali::DaliException e) {
48410       {
48411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48412       };
48413     } catch (...) {
48414       {
48415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48416       };
48417     }
48418   }
48419
48420   jresult = result;
48421   return jresult;
48422 }
48423
48424
48425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
48426   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48427   float arg2 ;
48428
48429   arg1 = (Dali::CameraActor *)jarg1;
48430   arg2 = (float)jarg2;
48431   {
48432     try {
48433       (arg1)->SetNearClippingPlane(arg2);
48434     } catch (std::out_of_range& e) {
48435       {
48436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48437       };
48438     } catch (std::exception& e) {
48439       {
48440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48441       };
48442     } catch (Dali::DaliException e) {
48443       {
48444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48445       };
48446     } catch (...) {
48447       {
48448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48449       };
48450     }
48451   }
48452
48453 }
48454
48455
48456 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
48457   float jresult ;
48458   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48459   float result;
48460
48461   arg1 = (Dali::CameraActor *)jarg1;
48462   {
48463     try {
48464       result = (float)(arg1)->GetNearClippingPlane();
48465     } catch (std::out_of_range& e) {
48466       {
48467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48468       };
48469     } catch (std::exception& e) {
48470       {
48471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48472       };
48473     } catch (Dali::DaliException e) {
48474       {
48475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48476       };
48477     } catch (...) {
48478       {
48479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48480       };
48481     }
48482   }
48483
48484   jresult = result;
48485   return jresult;
48486 }
48487
48488
48489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
48490   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48491   float arg2 ;
48492
48493   arg1 = (Dali::CameraActor *)jarg1;
48494   arg2 = (float)jarg2;
48495   {
48496     try {
48497       (arg1)->SetFarClippingPlane(arg2);
48498     } catch (std::out_of_range& e) {
48499       {
48500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48501       };
48502     } catch (std::exception& e) {
48503       {
48504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48505       };
48506     } catch (Dali::DaliException e) {
48507       {
48508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48509       };
48510     } catch (...) {
48511       {
48512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48513       };
48514     }
48515   }
48516
48517 }
48518
48519
48520 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
48521   float jresult ;
48522   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48523   float result;
48524
48525   arg1 = (Dali::CameraActor *)jarg1;
48526   {
48527     try {
48528       result = (float)(arg1)->GetFarClippingPlane();
48529     } catch (std::out_of_range& e) {
48530       {
48531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48532       };
48533     } catch (std::exception& e) {
48534       {
48535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48536       };
48537     } catch (Dali::DaliException e) {
48538       {
48539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48540       };
48541     } catch (...) {
48542       {
48543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48544       };
48545     }
48546   }
48547
48548   jresult = result;
48549   return jresult;
48550 }
48551
48552
48553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
48554   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48555   Dali::Vector3 *arg2 = 0 ;
48556
48557   arg1 = (Dali::CameraActor *)jarg1;
48558   arg2 = (Dali::Vector3 *)jarg2;
48559   if (!arg2) {
48560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
48561     return ;
48562   }
48563   {
48564     try {
48565       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
48566     } catch (std::out_of_range& e) {
48567       {
48568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48569       };
48570     } catch (std::exception& e) {
48571       {
48572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48573       };
48574     } catch (Dali::DaliException e) {
48575       {
48576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48577       };
48578     } catch (...) {
48579       {
48580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48581       };
48582     }
48583   }
48584
48585 }
48586
48587
48588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
48589   void * jresult ;
48590   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48591   Dali::Vector3 result;
48592
48593   arg1 = (Dali::CameraActor *)jarg1;
48594   {
48595     try {
48596       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
48597     } catch (std::out_of_range& e) {
48598       {
48599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48600       };
48601     } catch (std::exception& e) {
48602       {
48603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48604       };
48605     } catch (Dali::DaliException e) {
48606       {
48607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48608       };
48609     } catch (...) {
48610       {
48611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48612       };
48613     }
48614   }
48615
48616   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
48617   return jresult;
48618 }
48619
48620
48621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
48622   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48623   bool arg2 ;
48624
48625   arg1 = (Dali::CameraActor *)jarg1;
48626   arg2 = jarg2 ? true : false;
48627   {
48628     try {
48629       (arg1)->SetInvertYAxis(arg2);
48630     } catch (std::out_of_range& e) {
48631       {
48632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48633       };
48634     } catch (std::exception& e) {
48635       {
48636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48637       };
48638     } catch (Dali::DaliException e) {
48639       {
48640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48641       };
48642     } catch (...) {
48643       {
48644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48645       };
48646     }
48647   }
48648
48649 }
48650
48651
48652 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
48653   unsigned int jresult ;
48654   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48655   bool result;
48656
48657   arg1 = (Dali::CameraActor *)jarg1;
48658   {
48659     try {
48660       result = (bool)(arg1)->GetInvertYAxis();
48661     } catch (std::out_of_range& e) {
48662       {
48663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48664       };
48665     } catch (std::exception& e) {
48666       {
48667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48668       };
48669     } catch (Dali::DaliException e) {
48670       {
48671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48672       };
48673     } catch (...) {
48674       {
48675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48676       };
48677     }
48678   }
48679
48680   jresult = result;
48681   return jresult;
48682 }
48683
48684
48685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
48686   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48687   Dali::Size *arg2 = 0 ;
48688
48689   arg1 = (Dali::CameraActor *)jarg1;
48690   arg2 = (Dali::Size *)jarg2;
48691   if (!arg2) {
48692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48693     return ;
48694   }
48695   {
48696     try {
48697       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
48698     } catch (std::out_of_range& e) {
48699       {
48700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48701       };
48702     } catch (std::exception& e) {
48703       {
48704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48705       };
48706     } catch (Dali::DaliException e) {
48707       {
48708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48709       };
48710     } catch (...) {
48711       {
48712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48713       };
48714     }
48715   }
48716
48717 }
48718
48719
48720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
48721   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48722   Dali::Size *arg2 = 0 ;
48723
48724   arg1 = (Dali::CameraActor *)jarg1;
48725   arg2 = (Dali::Size *)jarg2;
48726   if (!arg2) {
48727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48728     return ;
48729   }
48730   {
48731     try {
48732       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
48733     } catch (std::out_of_range& e) {
48734       {
48735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48736       };
48737     } catch (std::exception& e) {
48738       {
48739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48740       };
48741     } catch (Dali::DaliException e) {
48742       {
48743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48744       };
48745     } catch (...) {
48746       {
48747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48748       };
48749     }
48750   }
48751
48752 }
48753
48754
48755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
48756   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48757   float arg2 ;
48758   float arg3 ;
48759   float arg4 ;
48760   float arg5 ;
48761   float arg6 ;
48762   float arg7 ;
48763
48764   arg1 = (Dali::CameraActor *)jarg1;
48765   arg2 = (float)jarg2;
48766   arg3 = (float)jarg3;
48767   arg4 = (float)jarg4;
48768   arg5 = (float)jarg5;
48769   arg6 = (float)jarg6;
48770   arg7 = (float)jarg7;
48771   {
48772     try {
48773       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
48774     } catch (std::out_of_range& e) {
48775       {
48776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48777       };
48778     } catch (std::exception& e) {
48779       {
48780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48781       };
48782     } catch (Dali::DaliException e) {
48783       {
48784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48785       };
48786     } catch (...) {
48787       {
48788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48789       };
48790     }
48791   }
48792
48793 }
48794
48795
48796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
48797   void * jresult ;
48798   std::pair< std::string,Dali::Property::Value > *result = 0 ;
48799
48800   {
48801     try {
48802       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
48803     } catch (std::out_of_range& e) {
48804       {
48805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48806       };
48807     } catch (std::exception& e) {
48808       {
48809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48810       };
48811     } catch (Dali::DaliException e) {
48812       {
48813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48814       };
48815     } catch (...) {
48816       {
48817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48818       };
48819     }
48820   }
48821
48822   jresult = (void *)result;
48823   return jresult;
48824 }
48825
48826
48827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
48828   void * jresult ;
48829   std::string arg1 ;
48830   Dali::Property::Value arg2 ;
48831   Dali::Property::Value *argp2 ;
48832   std::pair< std::string,Dali::Property::Value > *result = 0 ;
48833
48834   if (!jarg1) {
48835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48836     return 0;
48837   }
48838   (&arg1)->assign(jarg1);
48839   argp2 = (Dali::Property::Value *)jarg2;
48840   if (!argp2) {
48841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
48842     return 0;
48843   }
48844   arg2 = *argp2;
48845   {
48846     try {
48847       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
48848     } catch (std::out_of_range& e) {
48849       {
48850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48851       };
48852     } catch (std::exception& e) {
48853       {
48854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48855       };
48856     } catch (Dali::DaliException e) {
48857       {
48858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48859       };
48860     } catch (...) {
48861       {
48862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48863       };
48864     }
48865   }
48866
48867   jresult = (void *)result;
48868   return jresult;
48869 }
48870
48871
48872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
48873   void * jresult ;
48874   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
48875   std::pair< std::string,Dali::Property::Value > *result = 0 ;
48876
48877   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
48878   if (!arg1) {
48879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
48880     return 0;
48881   }
48882   {
48883     try {
48884       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);
48885     } catch (std::out_of_range& e) {
48886       {
48887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48888       };
48889     } catch (std::exception& e) {
48890       {
48891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48892       };
48893     } catch (Dali::DaliException e) {
48894       {
48895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48896       };
48897     } catch (...) {
48898       {
48899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48900       };
48901     }
48902   }
48903
48904   jresult = (void *)result;
48905   return jresult;
48906 }
48907
48908
48909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
48910   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
48911   std::string *arg2 = 0 ;
48912
48913   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
48914   if (!jarg2) {
48915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48916     return ;
48917   }
48918   std::string arg2_str(jarg2);
48919   arg2 = &arg2_str;
48920   if (arg1) (arg1)->first = *arg2;
48921
48922   //argout typemap for const std::string&
48923
48924 }
48925
48926
48927 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
48928   char * jresult ;
48929   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
48930   std::string *result = 0 ;
48931
48932   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
48933   result = (std::string *) & ((arg1)->first);
48934   jresult = SWIG_csharp_string_callback(result->c_str());
48935   return jresult;
48936 }
48937
48938
48939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
48940   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
48941   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
48942
48943   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
48944   arg2 = (Dali::Property::Value *)jarg2;
48945   if (arg1) (arg1)->second = *arg2;
48946 }
48947
48948
48949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
48950   void * jresult ;
48951   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
48952   Dali::Property::Value *result = 0 ;
48953
48954   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
48955   result = (Dali::Property::Value *)& ((arg1)->second);
48956   jresult = (void *)result;
48957   return jresult;
48958 }
48959
48960
48961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
48962   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
48963
48964   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
48965   {
48966     try {
48967       delete arg1;
48968     } catch (std::out_of_range& e) {
48969       {
48970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48971       };
48972     } catch (std::exception& e) {
48973       {
48974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48975       };
48976     } catch (Dali::DaliException e) {
48977       {
48978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48979       };
48980     } catch (...) {
48981       {
48982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48983       };
48984     }
48985   }
48986
48987 }
48988
48989
48990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
48991   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
48992
48993   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
48994   {
48995     try {
48996       (arg1)->clear();
48997     } catch (std::out_of_range& e) {
48998       {
48999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49000       };
49001     } catch (std::exception& e) {
49002       {
49003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49004       };
49005     } catch (Dali::DaliException e) {
49006       {
49007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49008       };
49009     } catch (...) {
49010       {
49011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49012       };
49013     }
49014   }
49015
49016 }
49017
49018
49019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
49020   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49021   Dali::TouchPoint *arg2 = 0 ;
49022
49023   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49024   arg2 = (Dali::TouchPoint *)jarg2;
49025   if (!arg2) {
49026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49027     return ;
49028   }
49029   {
49030     try {
49031       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
49032     } catch (std::out_of_range& e) {
49033       {
49034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49035       };
49036     } catch (std::exception& e) {
49037       {
49038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49039       };
49040     } catch (Dali::DaliException e) {
49041       {
49042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49043       };
49044     } catch (...) {
49045       {
49046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49047       };
49048     }
49049   }
49050
49051 }
49052
49053
49054 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
49055   unsigned long jresult ;
49056   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49057   std::vector< Dali::TouchPoint >::size_type result;
49058
49059   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49060   {
49061     try {
49062       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
49063     } catch (std::out_of_range& e) {
49064       {
49065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49066       };
49067     } catch (std::exception& e) {
49068       {
49069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49070       };
49071     } catch (Dali::DaliException e) {
49072       {
49073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49074       };
49075     } catch (...) {
49076       {
49077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49078       };
49079     }
49080   }
49081
49082   jresult = (unsigned long)result;
49083   return jresult;
49084 }
49085
49086
49087 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
49088   unsigned long jresult ;
49089   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49090   std::vector< Dali::TouchPoint >::size_type result;
49091
49092   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49093   {
49094     try {
49095       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
49096     } catch (std::out_of_range& e) {
49097       {
49098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49099       };
49100     } catch (std::exception& e) {
49101       {
49102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49103       };
49104     } catch (Dali::DaliException e) {
49105       {
49106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49107       };
49108     } catch (...) {
49109       {
49110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49111       };
49112     }
49113   }
49114
49115   jresult = (unsigned long)result;
49116   return jresult;
49117 }
49118
49119
49120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
49121   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49122   std::vector< Dali::TouchPoint >::size_type arg2 ;
49123
49124   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49125   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
49126   {
49127     try {
49128       (arg1)->reserve(arg2);
49129     } catch (std::out_of_range& e) {
49130       {
49131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49132       };
49133     } catch (std::exception& e) {
49134       {
49135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49136       };
49137     } catch (Dali::DaliException e) {
49138       {
49139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49140       };
49141     } catch (...) {
49142       {
49143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49144       };
49145     }
49146   }
49147
49148 }
49149
49150
49151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
49152   void * jresult ;
49153   std::vector< Dali::TouchPoint > *result = 0 ;
49154
49155   {
49156     try {
49157       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
49158     } catch (std::out_of_range& e) {
49159       {
49160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49161       };
49162     } catch (std::exception& e) {
49163       {
49164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49165       };
49166     } catch (Dali::DaliException e) {
49167       {
49168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49169       };
49170     } catch (...) {
49171       {
49172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49173       };
49174     }
49175   }
49176
49177   jresult = (void *)result;
49178   return jresult;
49179 }
49180
49181
49182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
49183   void * jresult ;
49184   std::vector< Dali::TouchPoint > *arg1 = 0 ;
49185   std::vector< Dali::TouchPoint > *result = 0 ;
49186
49187   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49188   if (!arg1) {
49189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49190     return 0;
49191   }
49192   {
49193     try {
49194       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
49195     } catch (std::out_of_range& e) {
49196       {
49197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49198       };
49199     } catch (std::exception& e) {
49200       {
49201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49202       };
49203     } catch (Dali::DaliException e) {
49204       {
49205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49206       };
49207     } catch (...) {
49208       {
49209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49210       };
49211     }
49212   }
49213
49214   jresult = (void *)result;
49215   return jresult;
49216 }
49217
49218
49219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
49220   void * jresult ;
49221   int arg1 ;
49222   std::vector< Dali::TouchPoint > *result = 0 ;
49223
49224   arg1 = (int)jarg1;
49225   {
49226     try {
49227       try {
49228         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
49229       }
49230       catch(std::out_of_range &_e) {
49231         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49232         return 0;
49233       }
49234
49235     } catch (std::out_of_range& e) {
49236       {
49237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49238       };
49239     } catch (std::exception& e) {
49240       {
49241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49242       };
49243     } catch (Dali::DaliException e) {
49244       {
49245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49246       };
49247     } catch (...) {
49248       {
49249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49250       };
49251     }
49252   }
49253
49254   jresult = (void *)result;
49255   return jresult;
49256 }
49257
49258
49259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
49260   void * jresult ;
49261   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49262   int arg2 ;
49263   SwigValueWrapper< Dali::TouchPoint > result;
49264
49265   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49266   arg2 = (int)jarg2;
49267   {
49268     try {
49269       try {
49270         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
49271       }
49272       catch(std::out_of_range &_e) {
49273         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49274         return 0;
49275       }
49276
49277     } catch (std::out_of_range& e) {
49278       {
49279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49280       };
49281     } catch (std::exception& e) {
49282       {
49283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49284       };
49285     } catch (Dali::DaliException e) {
49286       {
49287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49288       };
49289     } catch (...) {
49290       {
49291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49292       };
49293     }
49294   }
49295
49296   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
49297   return jresult;
49298 }
49299
49300
49301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
49302   void * jresult ;
49303   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49304   int arg2 ;
49305   Dali::TouchPoint *result = 0 ;
49306
49307   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49308   arg2 = (int)jarg2;
49309   {
49310     try {
49311       try {
49312         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
49313       }
49314       catch(std::out_of_range &_e) {
49315         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49316         return 0;
49317       }
49318
49319     } catch (std::out_of_range& e) {
49320       {
49321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49322       };
49323     } catch (std::exception& e) {
49324       {
49325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49326       };
49327     } catch (Dali::DaliException e) {
49328       {
49329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49330       };
49331     } catch (...) {
49332       {
49333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49334       };
49335     }
49336   }
49337
49338   jresult = (void *)result;
49339   return jresult;
49340 }
49341
49342
49343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
49344   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49345   int arg2 ;
49346   Dali::TouchPoint *arg3 = 0 ;
49347
49348   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49349   arg2 = (int)jarg2;
49350   arg3 = (Dali::TouchPoint *)jarg3;
49351   if (!arg3) {
49352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49353     return ;
49354   }
49355   {
49356     try {
49357       try {
49358         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49359       }
49360       catch(std::out_of_range &_e) {
49361         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49362         return ;
49363       }
49364
49365     } catch (std::out_of_range& e) {
49366       {
49367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49368       };
49369     } catch (std::exception& e) {
49370       {
49371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49372       };
49373     } catch (Dali::DaliException e) {
49374       {
49375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49376       };
49377     } catch (...) {
49378       {
49379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49380       };
49381     }
49382   }
49383
49384 }
49385
49386
49387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
49388   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49389   std::vector< Dali::TouchPoint > *arg2 = 0 ;
49390
49391   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49392   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
49393   if (!arg2) {
49394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49395     return ;
49396   }
49397   {
49398     try {
49399       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
49400     } catch (std::out_of_range& e) {
49401       {
49402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49403       };
49404     } catch (std::exception& e) {
49405       {
49406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49407       };
49408     } catch (Dali::DaliException e) {
49409       {
49410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49411       };
49412     } catch (...) {
49413       {
49414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49415       };
49416     }
49417   }
49418
49419 }
49420
49421
49422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
49423   void * jresult ;
49424   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49425   int arg2 ;
49426   int arg3 ;
49427   std::vector< Dali::TouchPoint > *result = 0 ;
49428
49429   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49430   arg2 = (int)jarg2;
49431   arg3 = (int)jarg3;
49432   {
49433     try {
49434       try {
49435         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
49436       }
49437       catch(std::out_of_range &_e) {
49438         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49439         return 0;
49440       }
49441       catch(std::invalid_argument &_e) {
49442         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49443         return 0;
49444       }
49445
49446     } catch (std::out_of_range& e) {
49447       {
49448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49449       };
49450     } catch (std::exception& e) {
49451       {
49452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49453       };
49454     } catch (Dali::DaliException e) {
49455       {
49456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49457       };
49458     } catch (...) {
49459       {
49460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49461       };
49462     }
49463   }
49464
49465   jresult = (void *)result;
49466   return jresult;
49467 }
49468
49469
49470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
49471   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49472   int arg2 ;
49473   Dali::TouchPoint *arg3 = 0 ;
49474
49475   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49476   arg2 = (int)jarg2;
49477   arg3 = (Dali::TouchPoint *)jarg3;
49478   if (!arg3) {
49479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49480     return ;
49481   }
49482   {
49483     try {
49484       try {
49485         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49486       }
49487       catch(std::out_of_range &_e) {
49488         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49489         return ;
49490       }
49491
49492     } catch (std::out_of_range& e) {
49493       {
49494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49495       };
49496     } catch (std::exception& e) {
49497       {
49498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49499       };
49500     } catch (Dali::DaliException e) {
49501       {
49502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49503       };
49504     } catch (...) {
49505       {
49506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49507       };
49508     }
49509   }
49510
49511 }
49512
49513
49514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
49515   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49516   int arg2 ;
49517   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49518
49519   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49520   arg2 = (int)jarg2;
49521   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49522   if (!arg3) {
49523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49524     return ;
49525   }
49526   {
49527     try {
49528       try {
49529         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49530       }
49531       catch(std::out_of_range &_e) {
49532         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49533         return ;
49534       }
49535
49536     } catch (std::out_of_range& e) {
49537       {
49538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49539       };
49540     } catch (std::exception& e) {
49541       {
49542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49543       };
49544     } catch (Dali::DaliException e) {
49545       {
49546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49547       };
49548     } catch (...) {
49549       {
49550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49551       };
49552     }
49553   }
49554
49555 }
49556
49557
49558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
49559   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49560   int arg2 ;
49561
49562   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49563   arg2 = (int)jarg2;
49564   {
49565     try {
49566       try {
49567         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
49568       }
49569       catch(std::out_of_range &_e) {
49570         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49571         return ;
49572       }
49573
49574     } catch (std::out_of_range& e) {
49575       {
49576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49577       };
49578     } catch (std::exception& e) {
49579       {
49580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49581       };
49582     } catch (Dali::DaliException e) {
49583       {
49584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49585       };
49586     } catch (...) {
49587       {
49588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49589       };
49590     }
49591   }
49592
49593 }
49594
49595
49596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
49597   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49598   int arg2 ;
49599   int arg3 ;
49600
49601   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49602   arg2 = (int)jarg2;
49603   arg3 = (int)jarg3;
49604   {
49605     try {
49606       try {
49607         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
49608       }
49609       catch(std::out_of_range &_e) {
49610         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49611         return ;
49612       }
49613       catch(std::invalid_argument &_e) {
49614         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49615         return ;
49616       }
49617
49618     } catch (std::out_of_range& e) {
49619       {
49620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49621       };
49622     } catch (std::exception& e) {
49623       {
49624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49625       };
49626     } catch (Dali::DaliException e) {
49627       {
49628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49629       };
49630     } catch (...) {
49631       {
49632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49633       };
49634     }
49635   }
49636
49637 }
49638
49639
49640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
49641   void * jresult ;
49642   Dali::TouchPoint *arg1 = 0 ;
49643   int arg2 ;
49644   std::vector< Dali::TouchPoint > *result = 0 ;
49645
49646   arg1 = (Dali::TouchPoint *)jarg1;
49647   if (!arg1) {
49648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49649     return 0;
49650   }
49651   arg2 = (int)jarg2;
49652   {
49653     try {
49654       try {
49655         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
49656       }
49657       catch(std::out_of_range &_e) {
49658         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49659         return 0;
49660       }
49661
49662     } catch (std::out_of_range& e) {
49663       {
49664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49665       };
49666     } catch (std::exception& e) {
49667       {
49668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49669       };
49670     } catch (Dali::DaliException e) {
49671       {
49672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49673       };
49674     } catch (...) {
49675       {
49676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49677       };
49678     }
49679   }
49680
49681   jresult = (void *)result;
49682   return jresult;
49683 }
49684
49685
49686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
49687   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49688
49689   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49690   {
49691     try {
49692       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
49693     } catch (std::out_of_range& e) {
49694       {
49695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49696       };
49697     } catch (std::exception& e) {
49698       {
49699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49700       };
49701     } catch (Dali::DaliException e) {
49702       {
49703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49704       };
49705     } catch (...) {
49706       {
49707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49708       };
49709     }
49710   }
49711
49712 }
49713
49714
49715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
49716   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49717   int arg2 ;
49718   int arg3 ;
49719
49720   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49721   arg2 = (int)jarg2;
49722   arg3 = (int)jarg3;
49723   {
49724     try {
49725       try {
49726         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
49727       }
49728       catch(std::out_of_range &_e) {
49729         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49730         return ;
49731       }
49732       catch(std::invalid_argument &_e) {
49733         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49734         return ;
49735       }
49736
49737     } catch (std::out_of_range& e) {
49738       {
49739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49740       };
49741     } catch (std::exception& e) {
49742       {
49743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49744       };
49745     } catch (Dali::DaliException e) {
49746       {
49747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49748       };
49749     } catch (...) {
49750       {
49751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49752       };
49753     }
49754   }
49755
49756 }
49757
49758
49759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
49760   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49761   int arg2 ;
49762   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49763
49764   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49765   arg2 = (int)jarg2;
49766   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49767   if (!arg3) {
49768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49769     return ;
49770   }
49771   {
49772     try {
49773       try {
49774         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49775       }
49776       catch(std::out_of_range &_e) {
49777         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49778         return ;
49779       }
49780
49781     } catch (std::out_of_range& e) {
49782       {
49783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49784       };
49785     } catch (std::exception& e) {
49786       {
49787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49788       };
49789     } catch (Dali::DaliException e) {
49790       {
49791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49792       };
49793     } catch (...) {
49794       {
49795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49796       };
49797     }
49798   }
49799
49800 }
49801
49802
49803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
49804   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49805
49806   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49807   {
49808     try {
49809       delete arg1;
49810     } catch (std::out_of_range& e) {
49811       {
49812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49813       };
49814     } catch (std::exception& e) {
49815       {
49816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49817       };
49818     } catch (Dali::DaliException e) {
49819       {
49820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49821       };
49822     } catch (...) {
49823       {
49824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49825       };
49826     }
49827   }
49828
49829 }
49830
49831
49832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
49833   void * jresult ;
49834   Dali::Rect< int > *result = 0 ;
49835
49836   {
49837     try {
49838       result = (Dali::Rect< int > *)new Dali::Rect< int >();
49839     } catch (std::out_of_range& e) {
49840       {
49841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49842       };
49843     } catch (std::exception& e) {
49844       {
49845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49846       };
49847     } catch (Dali::DaliException e) {
49848       {
49849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49850       };
49851     } catch (...) {
49852       {
49853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49854       };
49855     }
49856   }
49857
49858   jresult = (void *)result;
49859   return jresult;
49860 }
49861
49862
49863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
49864   void * jresult ;
49865   int arg1 ;
49866   int arg2 ;
49867   int arg3 ;
49868   int arg4 ;
49869   Dali::Rect< int > *result = 0 ;
49870
49871   arg1 = (int)jarg1;
49872   arg2 = (int)jarg2;
49873   arg3 = (int)jarg3;
49874   arg4 = (int)jarg4;
49875   {
49876     try {
49877       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
49878     } catch (std::out_of_range& e) {
49879       {
49880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49881       };
49882     } catch (std::exception& e) {
49883       {
49884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49885       };
49886     } catch (Dali::DaliException e) {
49887       {
49888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49889       };
49890     } catch (...) {
49891       {
49892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49893       };
49894     }
49895   }
49896
49897   jresult = (void *)result;
49898   return jresult;
49899 }
49900
49901
49902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
49903   void * jresult ;
49904   Dali::Rect< int > *arg1 = 0 ;
49905   Dali::Rect< int > *result = 0 ;
49906
49907   arg1 = (Dali::Rect< int > *)jarg1;
49908   if (!arg1) {
49909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
49910     return 0;
49911   }
49912   {
49913     try {
49914       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
49915     } catch (std::out_of_range& e) {
49916       {
49917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49918       };
49919     } catch (std::exception& e) {
49920       {
49921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49922       };
49923     } catch (Dali::DaliException e) {
49924       {
49925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49926       };
49927     } catch (...) {
49928       {
49929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49930       };
49931     }
49932   }
49933
49934   jresult = (void *)result;
49935   return jresult;
49936 }
49937
49938
49939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
49940   void * jresult ;
49941   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
49942   Dali::Rect< int > *arg2 = 0 ;
49943   Dali::Rect< int > *result = 0 ;
49944
49945   arg1 = (Dali::Rect< int > *)jarg1;
49946   arg2 = (Dali::Rect< int > *)jarg2;
49947   if (!arg2) {
49948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
49949     return 0;
49950   }
49951   {
49952     try {
49953       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
49954     } catch (std::out_of_range& e) {
49955       {
49956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49957       };
49958     } catch (std::exception& e) {
49959       {
49960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49961       };
49962     } catch (Dali::DaliException e) {
49963       {
49964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49965       };
49966     } catch (...) {
49967       {
49968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49969       };
49970     }
49971   }
49972
49973   jresult = (void *)result;
49974   return jresult;
49975 }
49976
49977
49978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
49979   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
49980   int arg2 ;
49981   int arg3 ;
49982   int arg4 ;
49983   int arg5 ;
49984
49985   arg1 = (Dali::Rect< int > *)jarg1;
49986   arg2 = (int)jarg2;
49987   arg3 = (int)jarg3;
49988   arg4 = (int)jarg4;
49989   arg5 = (int)jarg5;
49990   {
49991     try {
49992       (arg1)->Set(arg2,arg3,arg4,arg5);
49993     } catch (std::out_of_range& e) {
49994       {
49995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49996       };
49997     } catch (std::exception& e) {
49998       {
49999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50000       };
50001     } catch (Dali::DaliException e) {
50002       {
50003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50004       };
50005     } catch (...) {
50006       {
50007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50008       };
50009     }
50010   }
50011
50012 }
50013
50014
50015 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
50016   unsigned int jresult ;
50017   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50018   bool result;
50019
50020   arg1 = (Dali::Rect< int > *)jarg1;
50021   {
50022     try {
50023       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
50024     } catch (std::out_of_range& e) {
50025       {
50026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50027       };
50028     } catch (std::exception& e) {
50029       {
50030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50031       };
50032     } catch (Dali::DaliException e) {
50033       {
50034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50035       };
50036     } catch (...) {
50037       {
50038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50039       };
50040     }
50041   }
50042
50043   jresult = result;
50044   return jresult;
50045 }
50046
50047
50048 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
50049   int jresult ;
50050   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50051   int result;
50052
50053   arg1 = (Dali::Rect< int > *)jarg1;
50054   {
50055     try {
50056       result = (int)((Dali::Rect< int > const *)arg1)->Left();
50057     } catch (std::out_of_range& e) {
50058       {
50059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50060       };
50061     } catch (std::exception& e) {
50062       {
50063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50064       };
50065     } catch (Dali::DaliException e) {
50066       {
50067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50068       };
50069     } catch (...) {
50070       {
50071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50072       };
50073     }
50074   }
50075
50076   jresult = result;
50077   return jresult;
50078 }
50079
50080
50081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
50082   int jresult ;
50083   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50084   int result;
50085
50086   arg1 = (Dali::Rect< int > *)jarg1;
50087   {
50088     try {
50089       result = (int)((Dali::Rect< int > const *)arg1)->Right();
50090     } catch (std::out_of_range& e) {
50091       {
50092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50093       };
50094     } catch (std::exception& e) {
50095       {
50096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50097       };
50098     } catch (Dali::DaliException e) {
50099       {
50100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50101       };
50102     } catch (...) {
50103       {
50104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50105       };
50106     }
50107   }
50108
50109   jresult = result;
50110   return jresult;
50111 }
50112
50113
50114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
50115   int jresult ;
50116   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50117   int result;
50118
50119   arg1 = (Dali::Rect< int > *)jarg1;
50120   {
50121     try {
50122       result = (int)((Dali::Rect< int > const *)arg1)->Top();
50123     } catch (std::out_of_range& e) {
50124       {
50125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50126       };
50127     } catch (std::exception& e) {
50128       {
50129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50130       };
50131     } catch (Dali::DaliException e) {
50132       {
50133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50134       };
50135     } catch (...) {
50136       {
50137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50138       };
50139     }
50140   }
50141
50142   jresult = result;
50143   return jresult;
50144 }
50145
50146
50147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
50148   int jresult ;
50149   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50150   int result;
50151
50152   arg1 = (Dali::Rect< int > *)jarg1;
50153   {
50154     try {
50155       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
50156     } catch (std::out_of_range& e) {
50157       {
50158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50159       };
50160     } catch (std::exception& e) {
50161       {
50162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50163       };
50164     } catch (Dali::DaliException e) {
50165       {
50166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50167       };
50168     } catch (...) {
50169       {
50170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50171       };
50172     }
50173   }
50174
50175   jresult = result;
50176   return jresult;
50177 }
50178
50179
50180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
50181   int jresult ;
50182   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50183   int result;
50184
50185   arg1 = (Dali::Rect< int > *)jarg1;
50186   {
50187     try {
50188       result = (int)((Dali::Rect< int > const *)arg1)->Area();
50189     } catch (std::out_of_range& e) {
50190       {
50191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50192       };
50193     } catch (std::exception& e) {
50194       {
50195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50196       };
50197     } catch (Dali::DaliException e) {
50198       {
50199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50200       };
50201     } catch (...) {
50202       {
50203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50204       };
50205     }
50206   }
50207
50208   jresult = result;
50209   return jresult;
50210 }
50211
50212
50213 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
50214   unsigned int jresult ;
50215   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50216   Dali::Rect< int > *arg2 = 0 ;
50217   bool result;
50218
50219   arg1 = (Dali::Rect< int > *)jarg1;
50220   arg2 = (Dali::Rect< int > *)jarg2;
50221   if (!arg2) {
50222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50223     return 0;
50224   }
50225   {
50226     try {
50227       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
50228     } catch (std::out_of_range& e) {
50229       {
50230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50231       };
50232     } catch (std::exception& e) {
50233       {
50234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50235       };
50236     } catch (Dali::DaliException e) {
50237       {
50238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50239       };
50240     } catch (...) {
50241       {
50242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50243       };
50244     }
50245   }
50246
50247   jresult = result;
50248   return jresult;
50249 }
50250
50251
50252 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
50253   unsigned int jresult ;
50254   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50255   Dali::Rect< int > *arg2 = 0 ;
50256   bool result;
50257
50258   arg1 = (Dali::Rect< int > *)jarg1;
50259   arg2 = (Dali::Rect< int > *)jarg2;
50260   if (!arg2) {
50261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50262     return 0;
50263   }
50264   {
50265     try {
50266       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
50267     } catch (std::out_of_range& e) {
50268       {
50269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50270       };
50271     } catch (std::exception& e) {
50272       {
50273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50274       };
50275     } catch (Dali::DaliException e) {
50276       {
50277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50278       };
50279     } catch (...) {
50280       {
50281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50282       };
50283     }
50284   }
50285
50286   jresult = result;
50287   return jresult;
50288 }
50289
50290
50291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
50292   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50293   int arg2 ;
50294
50295   arg1 = (Dali::Rect< int > *)jarg1;
50296   arg2 = (int)jarg2;
50297   if (arg1) (arg1)->x = arg2;
50298 }
50299
50300
50301 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
50302   int jresult ;
50303   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50304   int result;
50305
50306   arg1 = (Dali::Rect< int > *)jarg1;
50307   result = (int) ((arg1)->x);
50308   jresult = result;
50309   return jresult;
50310 }
50311
50312
50313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
50314   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50315   int arg2 ;
50316
50317   arg1 = (Dali::Rect< int > *)jarg1;
50318   arg2 = (int)jarg2;
50319   if (arg1) (arg1)->left = arg2;
50320 }
50321
50322
50323 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
50324   int jresult ;
50325   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50326   int result;
50327
50328   arg1 = (Dali::Rect< int > *)jarg1;
50329   result = (int) ((arg1)->left);
50330   jresult = result;
50331   return jresult;
50332 }
50333
50334
50335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
50336   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50337   int arg2 ;
50338
50339   arg1 = (Dali::Rect< int > *)jarg1;
50340   arg2 = (int)jarg2;
50341   if (arg1) (arg1)->y = arg2;
50342 }
50343
50344
50345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
50346   int jresult ;
50347   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50348   int result;
50349
50350   arg1 = (Dali::Rect< int > *)jarg1;
50351   result = (int) ((arg1)->y);
50352   jresult = result;
50353   return jresult;
50354 }
50355
50356
50357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
50358   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50359   int arg2 ;
50360
50361   arg1 = (Dali::Rect< int > *)jarg1;
50362   arg2 = (int)jarg2;
50363   if (arg1) (arg1)->right = arg2;
50364 }
50365
50366
50367 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
50368   int jresult ;
50369   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50370   int result;
50371
50372   arg1 = (Dali::Rect< int > *)jarg1;
50373   result = (int) ((arg1)->right);
50374   jresult = result;
50375   return jresult;
50376 }
50377
50378
50379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
50380   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50381   int arg2 ;
50382
50383   arg1 = (Dali::Rect< int > *)jarg1;
50384   arg2 = (int)jarg2;
50385   if (arg1) (arg1)->width = arg2;
50386 }
50387
50388
50389 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
50390   int jresult ;
50391   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50392   int result;
50393
50394   arg1 = (Dali::Rect< int > *)jarg1;
50395   result = (int) ((arg1)->width);
50396   jresult = result;
50397   return jresult;
50398 }
50399
50400
50401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
50402   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50403   int arg2 ;
50404
50405   arg1 = (Dali::Rect< int > *)jarg1;
50406   arg2 = (int)jarg2;
50407   if (arg1) (arg1)->bottom = arg2;
50408 }
50409
50410
50411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
50412   int jresult ;
50413   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50414   int result;
50415
50416   arg1 = (Dali::Rect< int > *)jarg1;
50417   result = (int) ((arg1)->bottom);
50418   jresult = result;
50419   return jresult;
50420 }
50421
50422
50423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
50424   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50425   int arg2 ;
50426
50427   arg1 = (Dali::Rect< int > *)jarg1;
50428   arg2 = (int)jarg2;
50429   if (arg1) (arg1)->height = arg2;
50430 }
50431
50432
50433 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
50434   int jresult ;
50435   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50436   int result;
50437
50438   arg1 = (Dali::Rect< int > *)jarg1;
50439   result = (int) ((arg1)->height);
50440   jresult = result;
50441   return jresult;
50442 }
50443
50444
50445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
50446   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50447   int arg2 ;
50448
50449   arg1 = (Dali::Rect< int > *)jarg1;
50450   arg2 = (int)jarg2;
50451   if (arg1) (arg1)->top = arg2;
50452 }
50453
50454
50455 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
50456   int jresult ;
50457   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50458   int result;
50459
50460   arg1 = (Dali::Rect< int > *)jarg1;
50461   result = (int) ((arg1)->top);
50462   jresult = result;
50463   return jresult;
50464 }
50465
50466
50467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
50468   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50469
50470   arg1 = (Dali::Rect< int > *)jarg1;
50471   {
50472     try {
50473       delete arg1;
50474     } catch (std::out_of_range& e) {
50475       {
50476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50477       };
50478     } catch (std::exception& e) {
50479       {
50480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50481       };
50482     } catch (Dali::DaliException e) {
50483       {
50484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50485       };
50486     } catch (...) {
50487       {
50488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50489       };
50490     }
50491   }
50492
50493 }
50494
50495
50496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
50497   void * jresult ;
50498   Dali::Rect< float > *result = 0 ;
50499
50500   {
50501     try {
50502       result = (Dali::Rect< float > *)new Dali::Rect< float >();
50503     } catch (std::out_of_range& e) {
50504       {
50505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50506       };
50507     } catch (std::exception& e) {
50508       {
50509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50510       };
50511     } catch (Dali::DaliException e) {
50512       {
50513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50514       };
50515     } catch (...) {
50516       {
50517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50518       };
50519     }
50520   }
50521
50522   jresult = (void *)result;
50523   return jresult;
50524 }
50525
50526
50527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
50528   void * jresult ;
50529   float arg1 ;
50530   float arg2 ;
50531   float arg3 ;
50532   float arg4 ;
50533   Dali::Rect< float > *result = 0 ;
50534
50535   arg1 = (float)jarg1;
50536   arg2 = (float)jarg2;
50537   arg3 = (float)jarg4;
50538   arg4 = (float)jarg3;
50539   {
50540     try {
50541       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
50542     } catch (std::out_of_range& e) {
50543       {
50544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50545       };
50546     } catch (std::exception& e) {
50547       {
50548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50549       };
50550     } catch (Dali::DaliException e) {
50551       {
50552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50553       };
50554     } catch (...) {
50555       {
50556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50557       };
50558     }
50559   }
50560
50561   jresult = (void *)result;
50562   return jresult;
50563 }
50564
50565
50566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
50567   void * jresult ;
50568   Dali::Rect< float > *arg1 = 0 ;
50569   Dali::Rect< float > *result = 0 ;
50570
50571   arg1 = (Dali::Rect< float > *)jarg1;
50572   if (!arg1) {
50573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50574     return 0;
50575   }
50576   {
50577     try {
50578       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
50579     } catch (std::out_of_range& e) {
50580       {
50581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50582       };
50583     } catch (std::exception& e) {
50584       {
50585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50586       };
50587     } catch (Dali::DaliException e) {
50588       {
50589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50590       };
50591     } catch (...) {
50592       {
50593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50594       };
50595     }
50596   }
50597
50598   jresult = (void *)result;
50599   return jresult;
50600 }
50601
50602
50603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
50604   void * jresult ;
50605   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50606   Dali::Rect< float > *arg2 = 0 ;
50607   Dali::Rect< float > *result = 0 ;
50608
50609   arg1 = (Dali::Rect< float > *)jarg1;
50610   arg2 = (Dali::Rect< float > *)jarg2;
50611   if (!arg2) {
50612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50613     return 0;
50614   }
50615   {
50616     try {
50617       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
50618     } catch (std::out_of_range& e) {
50619       {
50620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50621       };
50622     } catch (std::exception& e) {
50623       {
50624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50625       };
50626     } catch (Dali::DaliException e) {
50627       {
50628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50629       };
50630     } catch (...) {
50631       {
50632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50633       };
50634     }
50635   }
50636
50637   jresult = (void *)result;
50638   return jresult;
50639 }
50640
50641
50642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
50643   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50644   float arg2 ;
50645   float arg3 ;
50646   float arg4 ;
50647   float arg5 ;
50648
50649   arg1 = (Dali::Rect< float > *)jarg1;
50650   arg2 = (float)jarg2;
50651   arg3 = (float)jarg3;
50652   arg4 = (float)jarg5;
50653   arg5 = (float)jarg4;
50654   {
50655     try {
50656       (arg1)->Set(arg2,arg3,arg4,arg5);
50657     } catch (std::out_of_range& e) {
50658       {
50659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50660       };
50661     } catch (std::exception& e) {
50662       {
50663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50664       };
50665     } catch (Dali::DaliException e) {
50666       {
50667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50668       };
50669     } catch (...) {
50670       {
50671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50672       };
50673     }
50674   }
50675
50676 }
50677
50678
50679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
50680   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50681   float arg2 ;
50682
50683   arg1 = (Dali::Rect< float > *)jarg1;
50684   arg2 = (float)jarg2;
50685   if (arg1) (arg1)->left = arg2;
50686 }
50687
50688
50689 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
50690   float jresult ;
50691   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50692   float result;
50693
50694   arg1 = (Dali::Rect< float > *)jarg1;
50695   result = (float) ((arg1)->left);
50696   jresult = result;
50697   return jresult;
50698 }
50699
50700
50701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
50702   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50703   float arg2 ;
50704
50705   arg1 = (Dali::Rect< float > *)jarg1;
50706   arg2 = (float)jarg2;
50707   if (arg1) (arg1)->left = arg2;
50708 }
50709
50710
50711 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
50712   float jresult ;
50713   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50714   float result;
50715
50716   arg1 = (Dali::Rect< float > *)jarg1;
50717   result = (float) ((arg1)->left);
50718   jresult = result;
50719   return jresult;
50720 }
50721
50722
50723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
50724   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50725   float arg2 ;
50726
50727   arg1 = (Dali::Rect< float > *)jarg1;
50728   arg2 = (float)jarg2;
50729   if (arg1) (arg1)->right = arg2;
50730 }
50731
50732
50733 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
50734   float jresult ;
50735   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50736   float result;
50737
50738   arg1 = (Dali::Rect< float > *)jarg1;
50739   result = (float) ((arg1)->right);
50740   jresult = result;
50741   return jresult;
50742 }
50743
50744
50745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
50746   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50747   float arg2 ;
50748
50749   arg1 = (Dali::Rect< float > *)jarg1;
50750   arg2 = (float)jarg2;
50751   if (arg1) (arg1)->right = arg2;
50752 }
50753
50754
50755 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
50756   float jresult ;
50757   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50758   float result;
50759
50760   arg1 = (Dali::Rect< float > *)jarg1;
50761   result = (float) ((arg1)->right);
50762   jresult = result;
50763   return jresult;
50764 }
50765
50766
50767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
50768   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50769   float arg2 ;
50770
50771   arg1 = (Dali::Rect< float > *)jarg1;
50772   arg2 = (float)jarg2;
50773   if (arg1) (arg1)->bottom = arg2;
50774 }
50775
50776
50777 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
50778   float jresult ;
50779   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50780   float result;
50781
50782   arg1 = (Dali::Rect< float > *)jarg1;
50783   result = (float) ((arg1)->bottom);
50784   jresult = result;
50785   return jresult;
50786 }
50787
50788
50789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
50790   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50791   float arg2 ;
50792
50793   arg1 = (Dali::Rect< float > *)jarg1;
50794   arg2 = (float)jarg2;
50795   if (arg1) (arg1)->top = arg2;
50796 }
50797
50798
50799 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
50800   float jresult ;
50801   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50802   float result;
50803
50804   arg1 = (Dali::Rect< float > *)jarg1;
50805   result = (float) ((arg1)->top);
50806   jresult = result;
50807   return jresult;
50808 }
50809
50810
50811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
50812   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50813
50814   arg1 = (Dali::Rect< float > *)jarg1;
50815   {
50816     try {
50817       delete arg1;
50818     } catch (std::out_of_range& e) {
50819       {
50820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50821       };
50822     } catch (std::exception& e) {
50823       {
50824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50825       };
50826     } catch (Dali::DaliException e) {
50827       {
50828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50829       };
50830     } catch (...) {
50831       {
50832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50833       };
50834     }
50835   }
50836
50837 }
50838
50839
50840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
50841   int jresult ;
50842   int result;
50843
50844   result = (int)Dali::Vector< int >::BaseType;
50845   jresult = (int)result;
50846   return jresult;
50847 }
50848
50849
50850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
50851   void * jresult ;
50852   Dali::Vector< int > *result = 0 ;
50853
50854   {
50855     try {
50856       result = (Dali::Vector< int > *)new Dali::Vector< int >();
50857     } catch (std::out_of_range& e) {
50858       {
50859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50860       };
50861     } catch (std::exception& e) {
50862       {
50863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50864       };
50865     } catch (Dali::DaliException e) {
50866       {
50867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50868       };
50869     } catch (...) {
50870       {
50871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50872       };
50873     }
50874   }
50875
50876   jresult = (void *)result;
50877   return jresult;
50878 }
50879
50880
50881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
50882   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
50883
50884   arg1 = (Dali::Vector< int > *)jarg1;
50885   {
50886     try {
50887       delete arg1;
50888     } catch (std::out_of_range& e) {
50889       {
50890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50891       };
50892     } catch (std::exception& e) {
50893       {
50894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50895       };
50896     } catch (Dali::DaliException e) {
50897       {
50898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50899       };
50900     } catch (...) {
50901       {
50902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50903       };
50904     }
50905   }
50906
50907 }
50908
50909
50910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
50911   void * jresult ;
50912   Dali::Vector< int > *arg1 = 0 ;
50913   Dali::Vector< int > *result = 0 ;
50914
50915   arg1 = (Dali::Vector< int > *)jarg1;
50916   if (!arg1) {
50917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
50918     return 0;
50919   }
50920   {
50921     try {
50922       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
50923     } catch (std::out_of_range& e) {
50924       {
50925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50926       };
50927     } catch (std::exception& e) {
50928       {
50929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50930       };
50931     } catch (Dali::DaliException e) {
50932       {
50933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50934       };
50935     } catch (...) {
50936       {
50937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50938       };
50939     }
50940   }
50941
50942   jresult = (void *)result;
50943   return jresult;
50944 }
50945
50946
50947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
50948   void * jresult ;
50949   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
50950   Dali::Vector< int > *arg2 = 0 ;
50951   Dali::Vector< int > *result = 0 ;
50952
50953   arg1 = (Dali::Vector< int > *)jarg1;
50954   arg2 = (Dali::Vector< int > *)jarg2;
50955   if (!arg2) {
50956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
50957     return 0;
50958   }
50959   {
50960     try {
50961       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
50962     } catch (std::out_of_range& e) {
50963       {
50964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50965       };
50966     } catch (std::exception& e) {
50967       {
50968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50969       };
50970     } catch (Dali::DaliException e) {
50971       {
50972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50973       };
50974     } catch (...) {
50975       {
50976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50977       };
50978     }
50979   }
50980
50981   jresult = (void *)result;
50982   return jresult;
50983 }
50984
50985
50986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
50987   void * jresult ;
50988   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
50989   Dali::Vector< int >::Iterator result;
50990
50991   arg1 = (Dali::Vector< int > *)jarg1;
50992   {
50993     try {
50994       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
50995     } catch (std::out_of_range& e) {
50996       {
50997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50998       };
50999     } catch (std::exception& e) {
51000       {
51001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51002       };
51003     } catch (Dali::DaliException e) {
51004       {
51005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51006       };
51007     } catch (...) {
51008       {
51009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51010       };
51011     }
51012   }
51013
51014   jresult = (void *)result;
51015   return jresult;
51016 }
51017
51018
51019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
51020   void * jresult ;
51021   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51022   Dali::Vector< int >::Iterator result;
51023
51024   arg1 = (Dali::Vector< int > *)jarg1;
51025   {
51026     try {
51027       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
51028     } catch (std::out_of_range& e) {
51029       {
51030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51031       };
51032     } catch (std::exception& e) {
51033       {
51034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51035       };
51036     } catch (Dali::DaliException e) {
51037       {
51038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51039       };
51040     } catch (...) {
51041       {
51042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51043       };
51044     }
51045   }
51046
51047   jresult = (void *)result;
51048   return jresult;
51049 }
51050
51051
51052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51053   void * jresult ;
51054   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51055   Dali::Vector< int >::SizeType arg2 ;
51056   Dali::Vector< int >::ItemType *result = 0 ;
51057
51058   arg1 = (Dali::Vector< int > *)jarg1;
51059   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51060   {
51061     try {
51062       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
51063     } catch (std::out_of_range& e) {
51064       {
51065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51066       };
51067     } catch (std::exception& e) {
51068       {
51069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51070       };
51071     } catch (Dali::DaliException e) {
51072       {
51073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51074       };
51075     } catch (...) {
51076       {
51077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51078       };
51079     }
51080   }
51081
51082   jresult = (void *)result;
51083   return jresult;
51084 }
51085
51086
51087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
51088   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51089   Dali::Vector< int >::ItemType *arg2 = 0 ;
51090   Dali::Vector< int >::ItemType temp2 ;
51091
51092   arg1 = (Dali::Vector< int > *)jarg1;
51093   temp2 = (Dali::Vector< int >::ItemType)jarg2;
51094   arg2 = &temp2;
51095   {
51096     try {
51097       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
51098     } catch (std::out_of_range& e) {
51099       {
51100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51101       };
51102     } catch (std::exception& e) {
51103       {
51104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51105       };
51106     } catch (Dali::DaliException e) {
51107       {
51108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51109       };
51110     } catch (...) {
51111       {
51112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51113       };
51114     }
51115   }
51116
51117 }
51118
51119
51120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
51121   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51122   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51123   Dali::Vector< int >::ItemType *arg3 = 0 ;
51124   Dali::Vector< int >::ItemType temp3 ;
51125
51126   arg1 = (Dali::Vector< int > *)jarg1;
51127   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51128   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51129   arg3 = &temp3;
51130   {
51131     try {
51132       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51133     } catch (std::out_of_range& e) {
51134       {
51135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51136       };
51137     } catch (std::exception& e) {
51138       {
51139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51140       };
51141     } catch (Dali::DaliException e) {
51142       {
51143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51144       };
51145     } catch (...) {
51146       {
51147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51148       };
51149     }
51150   }
51151
51152 }
51153
51154
51155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51156   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51157   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51158   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51159   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
51160
51161   arg1 = (Dali::Vector< int > *)jarg1;
51162   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51163   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51164   arg4 = (Dali::Vector< int >::Iterator)jarg4;
51165   {
51166     try {
51167       (arg1)->Insert(arg2,arg3,arg4);
51168     } catch (std::out_of_range& e) {
51169       {
51170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51171       };
51172     } catch (std::exception& e) {
51173       {
51174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51175       };
51176     } catch (Dali::DaliException e) {
51177       {
51178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51179       };
51180     } catch (...) {
51181       {
51182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51183       };
51184     }
51185   }
51186
51187 }
51188
51189
51190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
51191   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51192   Dali::Vector< int >::SizeType arg2 ;
51193
51194   arg1 = (Dali::Vector< int > *)jarg1;
51195   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51196   {
51197     try {
51198       (arg1)->Reserve(arg2);
51199     } catch (std::out_of_range& e) {
51200       {
51201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51202       };
51203     } catch (std::exception& e) {
51204       {
51205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51206       };
51207     } catch (Dali::DaliException e) {
51208       {
51209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51210       };
51211     } catch (...) {
51212       {
51213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51214       };
51215     }
51216   }
51217
51218 }
51219
51220
51221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
51222   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51223   Dali::Vector< int >::SizeType arg2 ;
51224
51225   arg1 = (Dali::Vector< int > *)jarg1;
51226   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51227   {
51228     try {
51229       (arg1)->Resize(arg2);
51230     } catch (std::out_of_range& e) {
51231       {
51232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51233       };
51234     } catch (std::exception& e) {
51235       {
51236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51237       };
51238     } catch (Dali::DaliException e) {
51239       {
51240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51241       };
51242     } catch (...) {
51243       {
51244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51245       };
51246     }
51247   }
51248
51249 }
51250
51251
51252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
51253   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51254   Dali::Vector< int >::SizeType arg2 ;
51255   Dali::Vector< int >::ItemType *arg3 = 0 ;
51256   Dali::Vector< int >::ItemType temp3 ;
51257
51258   arg1 = (Dali::Vector< int > *)jarg1;
51259   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51260   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51261   arg3 = &temp3;
51262   {
51263     try {
51264       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51265     } catch (std::out_of_range& e) {
51266       {
51267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51268       };
51269     } catch (std::exception& e) {
51270       {
51271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51272       };
51273     } catch (Dali::DaliException e) {
51274       {
51275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51276       };
51277     } catch (...) {
51278       {
51279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51280       };
51281     }
51282   }
51283
51284 }
51285
51286
51287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
51288   void * jresult ;
51289   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51290   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51291   Dali::Vector< int >::Iterator result;
51292
51293   arg1 = (Dali::Vector< int > *)jarg1;
51294   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51295   {
51296     try {
51297       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
51298     } catch (std::out_of_range& e) {
51299       {
51300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51301       };
51302     } catch (std::exception& e) {
51303       {
51304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51305       };
51306     } catch (Dali::DaliException e) {
51307       {
51308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51309       };
51310     } catch (...) {
51311       {
51312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51313       };
51314     }
51315   }
51316
51317   jresult = (void *)result;
51318   return jresult;
51319 }
51320
51321
51322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
51323   void * jresult ;
51324   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51325   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51326   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51327   Dali::Vector< int >::Iterator result;
51328
51329   arg1 = (Dali::Vector< int > *)jarg1;
51330   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51331   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51332   {
51333     try {
51334       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
51335     } catch (std::out_of_range& e) {
51336       {
51337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51338       };
51339     } catch (std::exception& e) {
51340       {
51341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51342       };
51343     } catch (Dali::DaliException e) {
51344       {
51345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51346       };
51347     } catch (...) {
51348       {
51349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51350       };
51351     }
51352   }
51353
51354   jresult = (void *)result;
51355   return jresult;
51356 }
51357
51358
51359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
51360   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51361   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51362
51363   arg1 = (Dali::Vector< int > *)jarg1;
51364   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51365   {
51366     try {
51367       (arg1)->Remove(arg2);
51368     } catch (std::out_of_range& e) {
51369       {
51370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51371       };
51372     } catch (std::exception& e) {
51373       {
51374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51375       };
51376     } catch (Dali::DaliException e) {
51377       {
51378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51379       };
51380     } catch (...) {
51381       {
51382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51383       };
51384     }
51385   }
51386
51387 }
51388
51389
51390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
51391   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51392   Dali::Vector< int > *arg2 = 0 ;
51393
51394   arg1 = (Dali::Vector< int > *)jarg1;
51395   arg2 = (Dali::Vector< int > *)jarg2;
51396   if (!arg2) {
51397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
51398     return ;
51399   }
51400   {
51401     try {
51402       (arg1)->Swap(*arg2);
51403     } catch (std::out_of_range& e) {
51404       {
51405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51406       };
51407     } catch (std::exception& e) {
51408       {
51409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51410       };
51411     } catch (Dali::DaliException e) {
51412       {
51413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51414       };
51415     } catch (...) {
51416       {
51417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51418       };
51419     }
51420   }
51421
51422 }
51423
51424
51425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
51426   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51427
51428   arg1 = (Dali::Vector< int > *)jarg1;
51429   {
51430     try {
51431       (arg1)->Clear();
51432     } catch (std::out_of_range& e) {
51433       {
51434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51435       };
51436     } catch (std::exception& e) {
51437       {
51438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51439       };
51440     } catch (Dali::DaliException e) {
51441       {
51442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51443       };
51444     } catch (...) {
51445       {
51446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51447       };
51448     }
51449   }
51450
51451 }
51452
51453
51454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
51455   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51456
51457   arg1 = (Dali::Vector< int > *)jarg1;
51458   {
51459     try {
51460       (arg1)->Release();
51461     } catch (std::out_of_range& e) {
51462       {
51463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51464       };
51465     } catch (std::exception& e) {
51466       {
51467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51468       };
51469     } catch (Dali::DaliException e) {
51470       {
51471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51472       };
51473     } catch (...) {
51474       {
51475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51476       };
51477     }
51478   }
51479
51480 }
51481
51482
51483 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
51484   int jresult ;
51485   int result;
51486
51487   result = (int)Dali::Vector< float >::BaseType;
51488   jresult = (int)result;
51489   return jresult;
51490 }
51491
51492
51493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
51494   void * jresult ;
51495   Dali::Vector< float > *result = 0 ;
51496
51497   {
51498     try {
51499       result = (Dali::Vector< float > *)new Dali::Vector< float >();
51500     } catch (std::out_of_range& e) {
51501       {
51502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51503       };
51504     } catch (std::exception& e) {
51505       {
51506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51507       };
51508     } catch (Dali::DaliException e) {
51509       {
51510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51511       };
51512     } catch (...) {
51513       {
51514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51515       };
51516     }
51517   }
51518
51519   jresult = (void *)result;
51520   return jresult;
51521 }
51522
51523
51524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
51525   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51526
51527   arg1 = (Dali::Vector< float > *)jarg1;
51528   {
51529     try {
51530       delete arg1;
51531     } catch (std::out_of_range& e) {
51532       {
51533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51534       };
51535     } catch (std::exception& e) {
51536       {
51537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51538       };
51539     } catch (Dali::DaliException e) {
51540       {
51541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51542       };
51543     } catch (...) {
51544       {
51545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51546       };
51547     }
51548   }
51549
51550 }
51551
51552
51553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
51554   void * jresult ;
51555   Dali::Vector< float > *arg1 = 0 ;
51556   Dali::Vector< float > *result = 0 ;
51557
51558   arg1 = (Dali::Vector< float > *)jarg1;
51559   if (!arg1) {
51560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51561     return 0;
51562   }
51563   {
51564     try {
51565       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
51566     } catch (std::out_of_range& e) {
51567       {
51568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51569       };
51570     } catch (std::exception& e) {
51571       {
51572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51573       };
51574     } catch (Dali::DaliException e) {
51575       {
51576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51577       };
51578     } catch (...) {
51579       {
51580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51581       };
51582     }
51583   }
51584
51585   jresult = (void *)result;
51586   return jresult;
51587 }
51588
51589
51590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
51591   void * jresult ;
51592   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51593   Dali::Vector< float > *arg2 = 0 ;
51594   Dali::Vector< float > *result = 0 ;
51595
51596   arg1 = (Dali::Vector< float > *)jarg1;
51597   arg2 = (Dali::Vector< float > *)jarg2;
51598   if (!arg2) {
51599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51600     return 0;
51601   }
51602   {
51603     try {
51604       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
51605     } catch (std::out_of_range& e) {
51606       {
51607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51608       };
51609     } catch (std::exception& e) {
51610       {
51611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51612       };
51613     } catch (Dali::DaliException e) {
51614       {
51615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51616       };
51617     } catch (...) {
51618       {
51619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51620       };
51621     }
51622   }
51623
51624   jresult = (void *)result;
51625   return jresult;
51626 }
51627
51628
51629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
51630   void * jresult ;
51631   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51632   Dali::Vector< float >::Iterator result;
51633
51634   arg1 = (Dali::Vector< float > *)jarg1;
51635   {
51636     try {
51637       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
51638     } catch (std::out_of_range& e) {
51639       {
51640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51641       };
51642     } catch (std::exception& e) {
51643       {
51644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51645       };
51646     } catch (Dali::DaliException e) {
51647       {
51648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51649       };
51650     } catch (...) {
51651       {
51652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51653       };
51654     }
51655   }
51656
51657   jresult = (void *)result;
51658   return jresult;
51659 }
51660
51661
51662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
51663   void * jresult ;
51664   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51665   Dali::Vector< float >::Iterator result;
51666
51667   arg1 = (Dali::Vector< float > *)jarg1;
51668   {
51669     try {
51670       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
51671     } catch (std::out_of_range& e) {
51672       {
51673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51674       };
51675     } catch (std::exception& e) {
51676       {
51677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51678       };
51679     } catch (Dali::DaliException e) {
51680       {
51681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51682       };
51683     } catch (...) {
51684       {
51685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51686       };
51687     }
51688   }
51689
51690   jresult = (void *)result;
51691   return jresult;
51692 }
51693
51694
51695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51696   void * jresult ;
51697   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51698   Dali::Vector< float >::SizeType arg2 ;
51699   Dali::Vector< float >::ItemType *result = 0 ;
51700
51701   arg1 = (Dali::Vector< float > *)jarg1;
51702   arg2 = (Dali::Vector< float >::SizeType)jarg2;
51703   {
51704     try {
51705       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
51706     } catch (std::out_of_range& e) {
51707       {
51708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51709       };
51710     } catch (std::exception& e) {
51711       {
51712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51713       };
51714     } catch (Dali::DaliException e) {
51715       {
51716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51717       };
51718     } catch (...) {
51719       {
51720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51721       };
51722     }
51723   }
51724
51725   jresult = (void *)result;
51726   return jresult;
51727 }
51728
51729
51730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
51731   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51732   Dali::Vector< float >::ItemType *arg2 = 0 ;
51733   Dali::Vector< float >::ItemType temp2 ;
51734
51735   arg1 = (Dali::Vector< float > *)jarg1;
51736   temp2 = (Dali::Vector< float >::ItemType)jarg2;
51737   arg2 = &temp2;
51738   {
51739     try {
51740       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
51741     } catch (std::out_of_range& e) {
51742       {
51743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51744       };
51745     } catch (std::exception& e) {
51746       {
51747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51748       };
51749     } catch (Dali::DaliException e) {
51750       {
51751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51752       };
51753     } catch (...) {
51754       {
51755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51756       };
51757     }
51758   }
51759
51760 }
51761
51762
51763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
51764   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51765   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
51766   Dali::Vector< float >::ItemType *arg3 = 0 ;
51767   Dali::Vector< float >::ItemType temp3 ;
51768
51769   arg1 = (Dali::Vector< float > *)jarg1;
51770   arg2 = (Dali::Vector< float >::Iterator)jarg2;
51771   temp3 = (Dali::Vector< float >::ItemType)jarg3;
51772   arg3 = &temp3;
51773   {
51774     try {
51775       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
51776     } catch (std::out_of_range& e) {
51777       {
51778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51779       };
51780     } catch (std::exception& e) {
51781       {
51782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51783       };
51784     } catch (Dali::DaliException e) {
51785       {
51786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51787       };
51788     } catch (...) {
51789       {
51790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51791       };
51792     }
51793   }
51794
51795 }
51796
51797
51798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51799   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51800   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
51801   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
51802   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
51803
51804   arg1 = (Dali::Vector< float > *)jarg1;
51805   arg2 = (Dali::Vector< float >::Iterator)jarg2;
51806   arg3 = (Dali::Vector< float >::Iterator)jarg3;
51807   arg4 = (Dali::Vector< float >::Iterator)jarg4;
51808   {
51809     try {
51810       (arg1)->Insert(arg2,arg3,arg4);
51811     } catch (std::out_of_range& e) {
51812       {
51813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51814       };
51815     } catch (std::exception& e) {
51816       {
51817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51818       };
51819     } catch (Dali::DaliException e) {
51820       {
51821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51822       };
51823     } catch (...) {
51824       {
51825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51826       };
51827     }
51828   }
51829
51830 }
51831
51832
51833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
51834   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51835   Dali::Vector< float >::SizeType arg2 ;
51836
51837   arg1 = (Dali::Vector< float > *)jarg1;
51838   arg2 = (Dali::Vector< float >::SizeType)jarg2;
51839   {
51840     try {
51841       (arg1)->Reserve(arg2);
51842     } catch (std::out_of_range& e) {
51843       {
51844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51845       };
51846     } catch (std::exception& e) {
51847       {
51848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51849       };
51850     } catch (Dali::DaliException e) {
51851       {
51852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51853       };
51854     } catch (...) {
51855       {
51856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51857       };
51858     }
51859   }
51860
51861 }
51862
51863 //// ========================= end of part 2 =============================
51864
51865 //// ========================== start part 3 ===============================
51866
51867
51868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
51869   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51870   Dali::Vector< float >::SizeType arg2 ;
51871
51872   arg1 = (Dali::Vector< float > *)jarg1;
51873   arg2 = (Dali::Vector< float >::SizeType)jarg2;
51874   {
51875     try {
51876       (arg1)->Resize(arg2);
51877     } catch (std::out_of_range& e) {
51878       {
51879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51880       };
51881     } catch (std::exception& e) {
51882       {
51883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51884       };
51885     } catch (Dali::DaliException e) {
51886       {
51887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51888       };
51889     } catch (...) {
51890       {
51891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51892       };
51893     }
51894   }
51895
51896 }
51897
51898
51899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
51900   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51901   Dali::Vector< float >::SizeType arg2 ;
51902   Dali::Vector< float >::ItemType *arg3 = 0 ;
51903   Dali::Vector< float >::ItemType temp3 ;
51904
51905   arg1 = (Dali::Vector< float > *)jarg1;
51906   arg2 = (Dali::Vector< float >::SizeType)jarg2;
51907   temp3 = (Dali::Vector< float >::ItemType)jarg3;
51908   arg3 = &temp3;
51909   {
51910     try {
51911       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
51912     } catch (std::out_of_range& e) {
51913       {
51914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51915       };
51916     } catch (std::exception& e) {
51917       {
51918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51919       };
51920     } catch (Dali::DaliException e) {
51921       {
51922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51923       };
51924     } catch (...) {
51925       {
51926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51927       };
51928     }
51929   }
51930
51931 }
51932
51933
51934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
51935   void * jresult ;
51936   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51937   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
51938   Dali::Vector< float >::Iterator result;
51939
51940   arg1 = (Dali::Vector< float > *)jarg1;
51941   arg2 = (Dali::Vector< float >::Iterator)jarg2;
51942   {
51943     try {
51944       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
51945     } catch (std::out_of_range& e) {
51946       {
51947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51948       };
51949     } catch (std::exception& e) {
51950       {
51951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51952       };
51953     } catch (Dali::DaliException e) {
51954       {
51955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51956       };
51957     } catch (...) {
51958       {
51959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51960       };
51961     }
51962   }
51963
51964   jresult = (void *)result;
51965   return jresult;
51966 }
51967
51968
51969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
51970   void * jresult ;
51971   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51972   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
51973   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
51974   Dali::Vector< float >::Iterator result;
51975
51976   arg1 = (Dali::Vector< float > *)jarg1;
51977   arg2 = (Dali::Vector< float >::Iterator)jarg2;
51978   arg3 = (Dali::Vector< float >::Iterator)jarg3;
51979   {
51980     try {
51981       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
51982     } catch (std::out_of_range& e) {
51983       {
51984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51985       };
51986     } catch (std::exception& e) {
51987       {
51988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51989       };
51990     } catch (Dali::DaliException e) {
51991       {
51992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51993       };
51994     } catch (...) {
51995       {
51996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51997       };
51998     }
51999   }
52000
52001   jresult = (void *)result;
52002   return jresult;
52003 }
52004
52005
52006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
52007   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52008   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52009
52010   arg1 = (Dali::Vector< float > *)jarg1;
52011   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52012   {
52013     try {
52014       (arg1)->Remove(arg2);
52015     } catch (std::out_of_range& e) {
52016       {
52017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52018       };
52019     } catch (std::exception& e) {
52020       {
52021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52022       };
52023     } catch (Dali::DaliException e) {
52024       {
52025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52026       };
52027     } catch (...) {
52028       {
52029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52030       };
52031     }
52032   }
52033
52034 }
52035
52036
52037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
52038   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52039   Dali::Vector< float > *arg2 = 0 ;
52040
52041   arg1 = (Dali::Vector< float > *)jarg1;
52042   arg2 = (Dali::Vector< float > *)jarg2;
52043   if (!arg2) {
52044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
52045     return ;
52046   }
52047   {
52048     try {
52049       (arg1)->Swap(*arg2);
52050     } catch (std::out_of_range& e) {
52051       {
52052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52053       };
52054     } catch (std::exception& e) {
52055       {
52056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52057       };
52058     } catch (Dali::DaliException e) {
52059       {
52060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52061       };
52062     } catch (...) {
52063       {
52064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52065       };
52066     }
52067   }
52068
52069 }
52070
52071
52072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
52073   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52074
52075   arg1 = (Dali::Vector< float > *)jarg1;
52076   {
52077     try {
52078       (arg1)->Clear();
52079     } catch (std::out_of_range& e) {
52080       {
52081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52082       };
52083     } catch (std::exception& e) {
52084       {
52085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52086       };
52087     } catch (Dali::DaliException e) {
52088       {
52089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52090       };
52091     } catch (...) {
52092       {
52093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52094       };
52095     }
52096   }
52097
52098 }
52099
52100
52101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
52102   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52103
52104   arg1 = (Dali::Vector< float > *)jarg1;
52105   {
52106     try {
52107       (arg1)->Release();
52108     } catch (std::out_of_range& e) {
52109       {
52110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52111       };
52112     } catch (std::exception& e) {
52113       {
52114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52115       };
52116     } catch (Dali::DaliException e) {
52117       {
52118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52119       };
52120     } catch (...) {
52121       {
52122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52123       };
52124     }
52125   }
52126
52127 }
52128
52129
52130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
52131   int jresult ;
52132   int result;
52133
52134   result = (int)Dali::Vector< unsigned char >::BaseType;
52135   jresult = (int)result;
52136   return jresult;
52137 }
52138
52139
52140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
52141   void * jresult ;
52142   Dali::Vector< unsigned char > *result = 0 ;
52143
52144   {
52145     try {
52146       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
52147     } catch (std::out_of_range& e) {
52148       {
52149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52150       };
52151     } catch (std::exception& e) {
52152       {
52153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52154       };
52155     } catch (Dali::DaliException e) {
52156       {
52157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52158       };
52159     } catch (...) {
52160       {
52161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52162       };
52163     }
52164   }
52165
52166   jresult = (void *)result;
52167   return jresult;
52168 }
52169
52170
52171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
52172   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52173
52174   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52175   {
52176     try {
52177       delete arg1;
52178     } catch (std::out_of_range& e) {
52179       {
52180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52181       };
52182     } catch (std::exception& e) {
52183       {
52184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52185       };
52186     } catch (Dali::DaliException e) {
52187       {
52188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52189       };
52190     } catch (...) {
52191       {
52192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52193       };
52194     }
52195   }
52196
52197 }
52198
52199
52200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
52201   void * jresult ;
52202   Dali::Vector< unsigned char > *arg1 = 0 ;
52203   Dali::Vector< unsigned char > *result = 0 ;
52204
52205   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52206   if (!arg1) {
52207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52208     return 0;
52209   }
52210   {
52211     try {
52212       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
52213     } catch (std::out_of_range& e) {
52214       {
52215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52216       };
52217     } catch (std::exception& e) {
52218       {
52219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52220       };
52221     } catch (Dali::DaliException e) {
52222       {
52223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52224       };
52225     } catch (...) {
52226       {
52227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52228       };
52229     }
52230   }
52231
52232   jresult = (void *)result;
52233   return jresult;
52234 }
52235
52236
52237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
52238   void * jresult ;
52239   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52240   Dali::Vector< unsigned char > *arg2 = 0 ;
52241   Dali::Vector< unsigned char > *result = 0 ;
52242
52243   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52244   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52245   if (!arg2) {
52246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52247     return 0;
52248   }
52249   {
52250     try {
52251       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
52252     } catch (std::out_of_range& e) {
52253       {
52254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52255       };
52256     } catch (std::exception& e) {
52257       {
52258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52259       };
52260     } catch (Dali::DaliException e) {
52261       {
52262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52263       };
52264     } catch (...) {
52265       {
52266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52267       };
52268     }
52269   }
52270
52271   jresult = (void *)result;
52272   return jresult;
52273 }
52274
52275
52276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
52277   void * jresult ;
52278   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52279   Dali::Vector< unsigned char >::Iterator result;
52280
52281   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52282   {
52283     try {
52284       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
52285     } catch (std::out_of_range& e) {
52286       {
52287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52288       };
52289     } catch (std::exception& e) {
52290       {
52291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52292       };
52293     } catch (Dali::DaliException e) {
52294       {
52295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52296       };
52297     } catch (...) {
52298       {
52299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52300       };
52301     }
52302   }
52303
52304   jresult = (void *)result;
52305   return jresult;
52306 }
52307
52308
52309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
52310   void * jresult ;
52311   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52312   Dali::Vector< unsigned char >::Iterator result;
52313
52314   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52315   {
52316     try {
52317       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
52318     } catch (std::out_of_range& e) {
52319       {
52320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52321       };
52322     } catch (std::exception& e) {
52323       {
52324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52325       };
52326     } catch (Dali::DaliException e) {
52327       {
52328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52329       };
52330     } catch (...) {
52331       {
52332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52333       };
52334     }
52335   }
52336
52337   jresult = (void *)result;
52338   return jresult;
52339 }
52340
52341
52342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
52343   void * jresult ;
52344   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52345   Dali::Vector< unsigned char >::SizeType arg2 ;
52346   Dali::Vector< unsigned char >::ItemType *result = 0 ;
52347
52348   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52349   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52350   {
52351     try {
52352       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
52353     } catch (std::out_of_range& e) {
52354       {
52355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52356       };
52357     } catch (std::exception& e) {
52358       {
52359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52360       };
52361     } catch (Dali::DaliException e) {
52362       {
52363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52364       };
52365     } catch (...) {
52366       {
52367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52368       };
52369     }
52370   }
52371
52372   jresult = (void *)result;
52373   return jresult;
52374 }
52375
52376
52377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
52378   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52379   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
52380   Dali::Vector< unsigned char >::ItemType temp2 ;
52381
52382   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52383   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
52384   arg2 = &temp2;
52385   {
52386     try {
52387       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
52388     } catch (std::out_of_range& e) {
52389       {
52390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52391       };
52392     } catch (std::exception& e) {
52393       {
52394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52395       };
52396     } catch (Dali::DaliException e) {
52397       {
52398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52399       };
52400     } catch (...) {
52401       {
52402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52403       };
52404     }
52405   }
52406
52407 }
52408
52409
52410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
52411   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52412   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52413   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52414   Dali::Vector< unsigned char >::ItemType temp3 ;
52415
52416   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52417   arg2 = jarg2;
52418   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52419   arg3 = &temp3;
52420   {
52421     try {
52422       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52423     } catch (std::out_of_range& e) {
52424       {
52425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52426       };
52427     } catch (std::exception& e) {
52428       {
52429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52430       };
52431     } catch (Dali::DaliException e) {
52432       {
52433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52434       };
52435     } catch (...) {
52436       {
52437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52438       };
52439     }
52440   }
52441
52442
52443
52444 }
52445
52446
52447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
52448   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52449   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52450   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52451   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52452
52453   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52454   arg2 = jarg2;
52455   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52456   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
52457   {
52458     try {
52459       (arg1)->Insert(arg2,arg3,arg4);
52460     } catch (std::out_of_range& e) {
52461       {
52462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52463       };
52464     } catch (std::exception& e) {
52465       {
52466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52467       };
52468     } catch (Dali::DaliException e) {
52469       {
52470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52471       };
52472     } catch (...) {
52473       {
52474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52475       };
52476     }
52477   }
52478
52479
52480
52481 }
52482
52483
52484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
52485   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52486   Dali::Vector< unsigned char >::SizeType arg2 ;
52487
52488   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52489   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52490   {
52491     try {
52492       (arg1)->Reserve(arg2);
52493     } catch (std::out_of_range& e) {
52494       {
52495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52496       };
52497     } catch (std::exception& e) {
52498       {
52499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52500       };
52501     } catch (Dali::DaliException e) {
52502       {
52503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52504       };
52505     } catch (...) {
52506       {
52507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52508       };
52509     }
52510   }
52511
52512 }
52513
52514
52515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52516   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52517   Dali::Vector< unsigned char >::SizeType arg2 ;
52518
52519   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52520   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52521   {
52522     try {
52523       (arg1)->Resize(arg2);
52524     } catch (std::out_of_range& e) {
52525       {
52526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52527       };
52528     } catch (std::exception& e) {
52529       {
52530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52531       };
52532     } catch (Dali::DaliException e) {
52533       {
52534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52535       };
52536     } catch (...) {
52537       {
52538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52539       };
52540     }
52541   }
52542
52543 }
52544
52545
52546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
52547   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52548   Dali::Vector< unsigned char >::SizeType arg2 ;
52549   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52550   Dali::Vector< unsigned char >::ItemType temp3 ;
52551
52552   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52553   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52554   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52555   arg3 = &temp3;
52556   {
52557     try {
52558       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52559     } catch (std::out_of_range& e) {
52560       {
52561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52562       };
52563     } catch (std::exception& e) {
52564       {
52565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52566       };
52567     } catch (Dali::DaliException e) {
52568       {
52569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52570       };
52571     } catch (...) {
52572       {
52573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52574       };
52575     }
52576   }
52577
52578 }
52579
52580
52581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
52582   void * jresult ;
52583   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52584   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52585   Dali::Vector< unsigned char >::Iterator result;
52586
52587   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52588   arg2 = jarg2;
52589   {
52590     try {
52591       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
52592     } catch (std::out_of_range& e) {
52593       {
52594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52595       };
52596     } catch (std::exception& e) {
52597       {
52598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52599       };
52600     } catch (Dali::DaliException e) {
52601       {
52602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52603       };
52604     } catch (...) {
52605       {
52606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52607       };
52608     }
52609   }
52610
52611   jresult = (void *)result;
52612
52613
52614   return jresult;
52615 }
52616
52617
52618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
52619   void * jresult ;
52620   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52621   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52622   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52623   Dali::Vector< unsigned char >::Iterator result;
52624
52625   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52626   arg2 = jarg2;
52627   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52628   {
52629     try {
52630       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
52631     } catch (std::out_of_range& e) {
52632       {
52633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52634       };
52635     } catch (std::exception& e) {
52636       {
52637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52638       };
52639     } catch (Dali::DaliException e) {
52640       {
52641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52642       };
52643     } catch (...) {
52644       {
52645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52646       };
52647     }
52648   }
52649
52650   jresult = (void *)result;
52651
52652
52653   return jresult;
52654 }
52655
52656
52657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
52658   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52659   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52660
52661   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52662   arg2 = jarg2;
52663   {
52664     try {
52665       (arg1)->Remove(arg2);
52666     } catch (std::out_of_range& e) {
52667       {
52668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52669       };
52670     } catch (std::exception& e) {
52671       {
52672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52673       };
52674     } catch (Dali::DaliException e) {
52675       {
52676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52677       };
52678     } catch (...) {
52679       {
52680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52681       };
52682     }
52683   }
52684
52685
52686
52687 }
52688
52689
52690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
52691   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52692   Dali::Vector< unsigned char > *arg2 = 0 ;
52693
52694   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52695   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52696   if (!arg2) {
52697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
52698     return ;
52699   }
52700   {
52701     try {
52702       (arg1)->Swap(*arg2);
52703     } catch (std::out_of_range& e) {
52704       {
52705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52706       };
52707     } catch (std::exception& e) {
52708       {
52709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52710       };
52711     } catch (Dali::DaliException e) {
52712       {
52713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52714       };
52715     } catch (...) {
52716       {
52717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52718       };
52719     }
52720   }
52721
52722 }
52723
52724
52725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
52726   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52727
52728   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52729   {
52730     try {
52731       (arg1)->Clear();
52732     } catch (std::out_of_range& e) {
52733       {
52734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52735       };
52736     } catch (std::exception& e) {
52737       {
52738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52739       };
52740     } catch (Dali::DaliException e) {
52741       {
52742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52743       };
52744     } catch (...) {
52745       {
52746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52747       };
52748     }
52749   }
52750
52751 }
52752
52753
52754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
52755   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52756
52757   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52758   {
52759     try {
52760       (arg1)->Release();
52761     } catch (std::out_of_range& e) {
52762       {
52763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52764       };
52765     } catch (std::exception& e) {
52766       {
52767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52768       };
52769     } catch (Dali::DaliException e) {
52770       {
52771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52772       };
52773     } catch (...) {
52774       {
52775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52776       };
52777     }
52778   }
52779
52780 }
52781
52782
52783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
52784   int jresult ;
52785   int result;
52786
52787   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
52788   jresult = (int)result;
52789   return jresult;
52790 }
52791
52792
52793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
52794   void * jresult ;
52795   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
52796
52797   {
52798     try {
52799       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
52800     } catch (std::out_of_range& e) {
52801       {
52802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52803       };
52804     } catch (std::exception& e) {
52805       {
52806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52807       };
52808     } catch (Dali::DaliException e) {
52809       {
52810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52811       };
52812     } catch (...) {
52813       {
52814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52815       };
52816     }
52817   }
52818
52819   jresult = (void *)result;
52820   return jresult;
52821 }
52822
52823
52824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
52825   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
52826
52827   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
52828   {
52829     try {
52830       delete arg1;
52831     } catch (std::out_of_range& e) {
52832       {
52833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52834       };
52835     } catch (std::exception& e) {
52836       {
52837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52838       };
52839     } catch (Dali::DaliException e) {
52840       {
52841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52842       };
52843     } catch (...) {
52844       {
52845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52846       };
52847     }
52848   }
52849
52850 }
52851
52852
52853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
52854   void * jresult ;
52855   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
52856   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
52857
52858   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
52859   if (!arg1) {
52860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
52861     return 0;
52862   }
52863   {
52864     try {
52865       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
52866     } catch (std::out_of_range& e) {
52867       {
52868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52869       };
52870     } catch (std::exception& e) {
52871       {
52872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52873       };
52874     } catch (Dali::DaliException e) {
52875       {
52876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52877       };
52878     } catch (...) {
52879       {
52880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52881       };
52882     }
52883   }
52884
52885   jresult = (void *)result;
52886   return jresult;
52887 }
52888
52889
52890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
52891   void * jresult ;
52892   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
52893   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
52894   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
52895
52896   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
52897   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
52898   if (!arg2) {
52899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
52900     return 0;
52901   }
52902   {
52903     try {
52904       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
52905     } catch (std::out_of_range& e) {
52906       {
52907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52908       };
52909     } catch (std::exception& e) {
52910       {
52911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52912       };
52913     } catch (Dali::DaliException e) {
52914       {
52915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52916       };
52917     } catch (...) {
52918       {
52919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52920       };
52921     }
52922   }
52923
52924   jresult = (void *)result;
52925   return jresult;
52926 }
52927
52928
52929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
52930   void * jresult ;
52931   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
52932   Dali::Vector< Dali::Uint16Pair >::Iterator result;
52933
52934   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
52935   {
52936     try {
52937       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
52938     } catch (std::out_of_range& e) {
52939       {
52940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52941       };
52942     } catch (std::exception& e) {
52943       {
52944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52945       };
52946     } catch (Dali::DaliException e) {
52947       {
52948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52949       };
52950     } catch (...) {
52951       {
52952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52953       };
52954     }
52955   }
52956
52957   jresult = (void *)result;
52958   return jresult;
52959 }
52960
52961
52962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
52963   void * jresult ;
52964   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
52965   Dali::Vector< Dali::Uint16Pair >::Iterator result;
52966
52967   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
52968   {
52969     try {
52970       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
52971     } catch (std::out_of_range& e) {
52972       {
52973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52974       };
52975     } catch (std::exception& e) {
52976       {
52977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52978       };
52979     } catch (Dali::DaliException e) {
52980       {
52981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52982       };
52983     } catch (...) {
52984       {
52985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52986       };
52987     }
52988   }
52989
52990   jresult = (void *)result;
52991   return jresult;
52992 }
52993
52994
52995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
52996   void * jresult ;
52997   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
52998   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
52999   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
53000
53001   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53002   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53003   {
53004     try {
53005       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
53006     } catch (std::out_of_range& e) {
53007       {
53008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53009       };
53010     } catch (std::exception& e) {
53011       {
53012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53013       };
53014     } catch (Dali::DaliException e) {
53015       {
53016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53017       };
53018     } catch (...) {
53019       {
53020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53021       };
53022     }
53023   }
53024
53025   jresult = (void *)result;
53026   return jresult;
53027 }
53028
53029
53030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
53031   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53032   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
53033
53034   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53035   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
53036   if (!arg2) {
53037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53038     return ;
53039   }
53040   {
53041     try {
53042       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
53043     } catch (std::out_of_range& e) {
53044       {
53045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53046       };
53047     } catch (std::exception& e) {
53048       {
53049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53050       };
53051     } catch (Dali::DaliException e) {
53052       {
53053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53054       };
53055     } catch (...) {
53056       {
53057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53058       };
53059     }
53060   }
53061
53062 }
53063
53064
53065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
53066   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53067   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53068   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53069
53070   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53071   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53072   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53073   if (!arg3) {
53074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53075     return ;
53076   }
53077   {
53078     try {
53079       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53080     } catch (std::out_of_range& e) {
53081       {
53082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53083       };
53084     } catch (std::exception& e) {
53085       {
53086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53087       };
53088     } catch (Dali::DaliException e) {
53089       {
53090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53091       };
53092     } catch (...) {
53093       {
53094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53095       };
53096     }
53097   }
53098
53099 }
53100
53101
53102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
53103   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53104   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53105   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53106   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53107
53108   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53109   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53110   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53111   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
53112   {
53113     try {
53114       (arg1)->Insert(arg2,arg3,arg4);
53115     } catch (std::out_of_range& e) {
53116       {
53117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53118       };
53119     } catch (std::exception& e) {
53120       {
53121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53122       };
53123     } catch (Dali::DaliException e) {
53124       {
53125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53126       };
53127     } catch (...) {
53128       {
53129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53130       };
53131     }
53132   }
53133
53134 }
53135
53136
53137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
53138   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53139   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53140
53141   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53142   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53143   {
53144     try {
53145       (arg1)->Reserve(arg2);
53146     } catch (std::out_of_range& e) {
53147       {
53148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53149       };
53150     } catch (std::exception& e) {
53151       {
53152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53153       };
53154     } catch (Dali::DaliException e) {
53155       {
53156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53157       };
53158     } catch (...) {
53159       {
53160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53161       };
53162     }
53163   }
53164
53165 }
53166
53167
53168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
53169   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53170   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53171
53172   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53173   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53174   {
53175     try {
53176       (arg1)->Resize(arg2);
53177     } catch (std::out_of_range& e) {
53178       {
53179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53180       };
53181     } catch (std::exception& e) {
53182       {
53183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53184       };
53185     } catch (Dali::DaliException e) {
53186       {
53187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53188       };
53189     } catch (...) {
53190       {
53191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53192       };
53193     }
53194   }
53195
53196 }
53197
53198
53199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
53200   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53201   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53202   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53203
53204   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53205   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53206   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53207   if (!arg3) {
53208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53209     return ;
53210   }
53211   {
53212     try {
53213       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53214     } catch (std::out_of_range& e) {
53215       {
53216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53217       };
53218     } catch (std::exception& e) {
53219       {
53220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53221       };
53222     } catch (Dali::DaliException e) {
53223       {
53224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53225       };
53226     } catch (...) {
53227       {
53228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53229       };
53230     }
53231   }
53232
53233 }
53234
53235
53236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
53237   void * jresult ;
53238   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53239   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53240   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53241
53242   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53243   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53244   {
53245     try {
53246       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
53247     } catch (std::out_of_range& e) {
53248       {
53249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53250       };
53251     } catch (std::exception& e) {
53252       {
53253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53254       };
53255     } catch (Dali::DaliException e) {
53256       {
53257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53258       };
53259     } catch (...) {
53260       {
53261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53262       };
53263     }
53264   }
53265
53266   jresult = (void *)result;
53267   return jresult;
53268 }
53269
53270
53271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
53272   void * jresult ;
53273   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53274   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53275   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53276   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53277
53278   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53279   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53280   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53281   {
53282     try {
53283       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
53284     } catch (std::out_of_range& e) {
53285       {
53286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53287       };
53288     } catch (std::exception& e) {
53289       {
53290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53291       };
53292     } catch (Dali::DaliException e) {
53293       {
53294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53295       };
53296     } catch (...) {
53297       {
53298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53299       };
53300     }
53301   }
53302
53303   jresult = (void *)result;
53304   return jresult;
53305 }
53306
53307
53308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
53309   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53310   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53311
53312   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53313   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53314   {
53315     try {
53316       (arg1)->Remove(arg2);
53317     } catch (std::out_of_range& e) {
53318       {
53319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53320       };
53321     } catch (std::exception& e) {
53322       {
53323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53324       };
53325     } catch (Dali::DaliException e) {
53326       {
53327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53328       };
53329     } catch (...) {
53330       {
53331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53332       };
53333     }
53334   }
53335
53336 }
53337
53338
53339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
53340   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53341   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53342
53343   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53344   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53345   if (!arg2) {
53346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
53347     return ;
53348   }
53349   {
53350     try {
53351       (arg1)->Swap(*arg2);
53352     } catch (std::out_of_range& e) {
53353       {
53354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53355       };
53356     } catch (std::exception& e) {
53357       {
53358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53359       };
53360     } catch (Dali::DaliException e) {
53361       {
53362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53363       };
53364     } catch (...) {
53365       {
53366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53367       };
53368     }
53369   }
53370
53371 }
53372
53373
53374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
53375   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53376
53377   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53378   {
53379     try {
53380       (arg1)->Clear();
53381     } catch (std::out_of_range& e) {
53382       {
53383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53384       };
53385     } catch (std::exception& e) {
53386       {
53387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53388       };
53389     } catch (Dali::DaliException e) {
53390       {
53391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53392       };
53393     } catch (...) {
53394       {
53395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53396       };
53397     }
53398   }
53399
53400 }
53401
53402
53403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
53404   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53405
53406   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53407   {
53408     try {
53409       (arg1)->Release();
53410     } catch (std::out_of_range& e) {
53411       {
53412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53413       };
53414     } catch (std::exception& e) {
53415       {
53416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53417       };
53418     } catch (Dali::DaliException e) {
53419       {
53420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53421       };
53422     } catch (...) {
53423       {
53424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53425       };
53426     }
53427   }
53428
53429 }
53430
53431
53432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
53433   void * jresult ;
53434   Dali::Signal< void () > *result = 0 ;
53435
53436   {
53437     try {
53438       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
53439     } catch (std::out_of_range& e) {
53440       {
53441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53442       };
53443     } catch (std::exception& e) {
53444       {
53445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53446       };
53447     } catch (Dali::DaliException e) {
53448       {
53449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53450       };
53451     } catch (...) {
53452       {
53453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53454       };
53455     }
53456   }
53457
53458   jresult = (void *)result;
53459   return jresult;
53460 }
53461
53462
53463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
53464   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53465
53466   arg1 = (Dali::Signal< void () > *)jarg1;
53467   {
53468     try {
53469       delete arg1;
53470     } catch (std::out_of_range& e) {
53471       {
53472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53473       };
53474     } catch (std::exception& e) {
53475       {
53476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53477       };
53478     } catch (Dali::DaliException e) {
53479       {
53480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53481       };
53482     } catch (...) {
53483       {
53484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53485       };
53486     }
53487   }
53488
53489 }
53490
53491
53492 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
53493   unsigned int jresult ;
53494   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53495   bool result;
53496
53497   arg1 = (Dali::Signal< void () > *)jarg1;
53498   {
53499     try {
53500       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
53501     } catch (std::out_of_range& e) {
53502       {
53503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53504       };
53505     } catch (std::exception& e) {
53506       {
53507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53508       };
53509     } catch (Dali::DaliException e) {
53510       {
53511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53512       };
53513     } catch (...) {
53514       {
53515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53516       };
53517     }
53518   }
53519
53520   jresult = result;
53521   return jresult;
53522 }
53523
53524
53525 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
53526   unsigned long jresult ;
53527   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53528   std::size_t result;
53529
53530   arg1 = (Dali::Signal< void () > *)jarg1;
53531   {
53532     try {
53533       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
53534     } catch (std::out_of_range& e) {
53535       {
53536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53537       };
53538     } catch (std::exception& e) {
53539       {
53540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53541       };
53542     } catch (Dali::DaliException e) {
53543       {
53544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53545       };
53546     } catch (...) {
53547       {
53548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53549       };
53550     }
53551   }
53552
53553   jresult = (unsigned long)result;
53554   return jresult;
53555 }
53556
53557
53558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
53559   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53560   void (*arg2)() = (void (*)()) 0 ;
53561
53562   arg1 = (Dali::Signal< void () > *)jarg1;
53563   arg2 = (void (*)())jarg2;
53564   {
53565     try {
53566       (arg1)->Connect(arg2);
53567     } catch (std::out_of_range& e) {
53568       {
53569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53570       };
53571     } catch (std::exception& e) {
53572       {
53573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53574       };
53575     } catch (Dali::DaliException e) {
53576       {
53577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53578       };
53579     } catch (...) {
53580       {
53581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53582       };
53583     }
53584   }
53585
53586 }
53587
53588
53589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
53590   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53591   void (*arg2)() = (void (*)()) 0 ;
53592
53593   arg1 = (Dali::Signal< void () > *)jarg1;
53594   arg2 = (void (*)())jarg2;
53595   {
53596     try {
53597       (arg1)->Disconnect(arg2);
53598     } catch (std::out_of_range& e) {
53599       {
53600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53601       };
53602     } catch (std::exception& e) {
53603       {
53604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53605       };
53606     } catch (Dali::DaliException e) {
53607       {
53608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53609       };
53610     } catch (...) {
53611       {
53612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53613       };
53614     }
53615   }
53616
53617 }
53618
53619
53620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
53621   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53622   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
53623   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
53624
53625   arg1 = (Dali::Signal< void () > *)jarg1;
53626   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
53627   arg3 = (Dali::FunctorDelegate *)jarg3;
53628   {
53629     try {
53630       (arg1)->Connect(arg2,arg3);
53631     } catch (std::out_of_range& e) {
53632       {
53633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53634       };
53635     } catch (std::exception& e) {
53636       {
53637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53638       };
53639     } catch (Dali::DaliException e) {
53640       {
53641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53642       };
53643     } catch (...) {
53644       {
53645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53646       };
53647     }
53648   }
53649
53650 }
53651
53652
53653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
53654   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53655
53656   arg1 = (Dali::Signal< void () > *)jarg1;
53657   {
53658     try {
53659       (arg1)->Emit();
53660     } catch (std::out_of_range& e) {
53661       {
53662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53663       };
53664     } catch (std::exception& e) {
53665       {
53666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53667       };
53668     } catch (Dali::DaliException e) {
53669       {
53670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53671       };
53672     } catch (...) {
53673       {
53674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53675       };
53676     }
53677   }
53678
53679 }
53680
53681
53682 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
53683   unsigned int jresult ;
53684   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53685   bool result;
53686
53687   arg1 = (Dali::Signal< void (float) > *)jarg1;
53688   {
53689     try {
53690       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
53691     } catch (std::out_of_range& e) {
53692       {
53693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53694       };
53695     } catch (std::exception& e) {
53696       {
53697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53698       };
53699     } catch (Dali::DaliException e) {
53700       {
53701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53702       };
53703     } catch (...) {
53704       {
53705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53706       };
53707     }
53708   }
53709
53710   jresult = result;
53711   return jresult;
53712 }
53713
53714
53715 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
53716   unsigned long jresult ;
53717   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53718   std::size_t result;
53719
53720   arg1 = (Dali::Signal< void (float) > *)jarg1;
53721   {
53722     try {
53723       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
53724     } catch (std::out_of_range& e) {
53725       {
53726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53727       };
53728     } catch (std::exception& e) {
53729       {
53730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53731       };
53732     } catch (Dali::DaliException e) {
53733       {
53734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53735       };
53736     } catch (...) {
53737       {
53738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53739       };
53740     }
53741   }
53742
53743   jresult = (unsigned long)result;
53744   return jresult;
53745 }
53746
53747
53748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
53749   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53750   void (*arg2)(float) = (void (*)(float)) 0 ;
53751
53752   arg1 = (Dali::Signal< void (float) > *)jarg1;
53753   arg2 = (void (*)(float))jarg2;
53754   {
53755     try {
53756       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
53757     } catch (std::out_of_range& e) {
53758       {
53759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53760       };
53761     } catch (std::exception& e) {
53762       {
53763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53764       };
53765     } catch (Dali::DaliException e) {
53766       {
53767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53768       };
53769     } catch (...) {
53770       {
53771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53772       };
53773     }
53774   }
53775
53776 }
53777
53778
53779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
53780   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53781   void (*arg2)(float) = (void (*)(float)) 0 ;
53782
53783   arg1 = (Dali::Signal< void (float) > *)jarg1;
53784   arg2 = (void (*)(float))jarg2;
53785   {
53786     try {
53787       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
53788     } catch (std::out_of_range& e) {
53789       {
53790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53791       };
53792     } catch (std::exception& e) {
53793       {
53794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53795       };
53796     } catch (Dali::DaliException e) {
53797       {
53798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53799       };
53800     } catch (...) {
53801       {
53802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53803       };
53804     }
53805   }
53806
53807 }
53808
53809
53810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
53811   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53812   float arg2 ;
53813
53814   arg1 = (Dali::Signal< void (float) > *)jarg1;
53815   arg2 = (float)jarg2;
53816   {
53817     try {
53818       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
53819     } catch (std::out_of_range& e) {
53820       {
53821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53822       };
53823     } catch (std::exception& e) {
53824       {
53825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53826       };
53827     } catch (Dali::DaliException e) {
53828       {
53829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53830       };
53831     } catch (...) {
53832       {
53833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53834       };
53835     }
53836   }
53837
53838 }
53839
53840
53841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
53842   void * jresult ;
53843   Dali::Signal< void (float) > *result = 0 ;
53844
53845   {
53846     try {
53847       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
53848     } catch (std::out_of_range& e) {
53849       {
53850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53851       };
53852     } catch (std::exception& e) {
53853       {
53854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53855       };
53856     } catch (Dali::DaliException e) {
53857       {
53858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53859       };
53860     } catch (...) {
53861       {
53862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53863       };
53864     }
53865   }
53866
53867   jresult = (void *)result;
53868   return jresult;
53869 }
53870
53871
53872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
53873   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53874
53875   arg1 = (Dali::Signal< void (float) > *)jarg1;
53876   {
53877     try {
53878       delete arg1;
53879     } catch (std::out_of_range& e) {
53880       {
53881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53882       };
53883     } catch (std::exception& e) {
53884       {
53885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53886       };
53887     } catch (Dali::DaliException e) {
53888       {
53889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53890       };
53891     } catch (...) {
53892       {
53893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53894       };
53895     }
53896   }
53897
53898 }
53899
53900
53901 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
53902   unsigned int jresult ;
53903   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
53904   bool result;
53905
53906   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
53907   {
53908     try {
53909       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
53910     } catch (std::out_of_range& e) {
53911       {
53912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53913       };
53914     } catch (std::exception& e) {
53915       {
53916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53917       };
53918     } catch (Dali::DaliException e) {
53919       {
53920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53921       };
53922     } catch (...) {
53923       {
53924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53925       };
53926     }
53927   }
53928
53929   jresult = result;
53930   return jresult;
53931 }
53932
53933
53934 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
53935   unsigned long jresult ;
53936   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
53937   std::size_t result;
53938
53939   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
53940   {
53941     try {
53942       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
53943     } catch (std::out_of_range& e) {
53944       {
53945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53946       };
53947     } catch (std::exception& e) {
53948       {
53949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53950       };
53951     } catch (Dali::DaliException e) {
53952       {
53953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53954       };
53955     } catch (...) {
53956       {
53957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53958       };
53959     }
53960   }
53961
53962   jresult = (unsigned long)result;
53963   return jresult;
53964 }
53965
53966
53967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
53968   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
53969   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
53970
53971   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
53972   arg2 = (void (*)(Dali::BaseHandle))jarg2;
53973   {
53974     try {
53975       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
53976     } catch (std::out_of_range& e) {
53977       {
53978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53979       };
53980     } catch (std::exception& e) {
53981       {
53982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53983       };
53984     } catch (Dali::DaliException e) {
53985       {
53986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53987       };
53988     } catch (...) {
53989       {
53990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53991       };
53992     }
53993   }
53994
53995 }
53996
53997
53998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
53999   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54000   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54001
54002   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54003   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54004   {
54005     try {
54006       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
54007     } catch (std::out_of_range& e) {
54008       {
54009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54010       };
54011     } catch (std::exception& e) {
54012       {
54013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54014       };
54015     } catch (Dali::DaliException e) {
54016       {
54017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54018       };
54019     } catch (...) {
54020       {
54021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54022       };
54023     }
54024   }
54025
54026 }
54027
54028
54029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
54030   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54031   Dali::BaseHandle arg2 ;
54032   Dali::BaseHandle *argp2 ;
54033
54034   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54035   argp2 = (Dali::BaseHandle *)jarg2;
54036   if (!argp2) {
54037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54038     return ;
54039   }
54040   arg2 = *argp2;
54041   {
54042     try {
54043       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
54044     } catch (std::out_of_range& e) {
54045       {
54046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54047       };
54048     } catch (std::exception& e) {
54049       {
54050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54051       };
54052     } catch (Dali::DaliException e) {
54053       {
54054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54055       };
54056     } catch (...) {
54057       {
54058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54059       };
54060     }
54061   }
54062
54063 }
54064
54065
54066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
54067   void * jresult ;
54068   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
54069
54070   {
54071     try {
54072       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
54073     } catch (std::out_of_range& e) {
54074       {
54075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54076       };
54077     } catch (std::exception& e) {
54078       {
54079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54080       };
54081     } catch (Dali::DaliException e) {
54082       {
54083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54084       };
54085     } catch (...) {
54086       {
54087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54088       };
54089     }
54090   }
54091
54092   jresult = (void *)result;
54093   return jresult;
54094 }
54095
54096
54097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
54098   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54099
54100   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54101   {
54102     try {
54103       delete arg1;
54104     } catch (std::out_of_range& e) {
54105       {
54106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54107       };
54108     } catch (std::exception& e) {
54109       {
54110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54111       };
54112     } catch (Dali::DaliException e) {
54113       {
54114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54115       };
54116     } catch (...) {
54117       {
54118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54119       };
54120     }
54121   }
54122
54123 }
54124
54125
54126 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
54127   unsigned int jresult ;
54128   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54129   bool result;
54130
54131   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54132   {
54133     try {
54134       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54135     } catch (std::out_of_range& e) {
54136       {
54137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54138       };
54139     } catch (std::exception& e) {
54140       {
54141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54142       };
54143     } catch (Dali::DaliException e) {
54144       {
54145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54146       };
54147     } catch (...) {
54148       {
54149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54150       };
54151     }
54152   }
54153
54154   jresult = result;
54155   return jresult;
54156 }
54157
54158
54159 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
54160   unsigned long jresult ;
54161   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54162   std::size_t result;
54163
54164   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54165   {
54166     try {
54167       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54168     } catch (std::out_of_range& e) {
54169       {
54170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54171       };
54172     } catch (std::exception& e) {
54173       {
54174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54175       };
54176     } catch (Dali::DaliException e) {
54177       {
54178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54179       };
54180     } catch (...) {
54181       {
54182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54183       };
54184     }
54185   }
54186
54187   jresult = (unsigned long)result;
54188   return jresult;
54189 }
54190
54191
54192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
54193   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54194   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54195
54196   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54197   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54198   {
54199     try {
54200       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
54201     } catch (std::out_of_range& e) {
54202       {
54203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54204       };
54205     } catch (std::exception& e) {
54206       {
54207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54208       };
54209     } catch (Dali::DaliException e) {
54210       {
54211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54212       };
54213     } catch (...) {
54214       {
54215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54216       };
54217     }
54218   }
54219
54220 }
54221
54222
54223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
54224   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54225   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54226
54227   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54228   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54229   {
54230     try {
54231       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
54232     } catch (std::out_of_range& e) {
54233       {
54234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54235       };
54236     } catch (std::exception& e) {
54237       {
54238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54239       };
54240     } catch (Dali::DaliException e) {
54241       {
54242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54243       };
54244     } catch (...) {
54245       {
54246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54247       };
54248     }
54249   }
54250
54251 }
54252
54253
54254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
54255   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54256   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
54257
54258   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54259   arg2 = (Dali::RefObject *)jarg2;
54260   {
54261     try {
54262       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
54263     } catch (std::out_of_range& e) {
54264       {
54265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54266       };
54267     } catch (std::exception& e) {
54268       {
54269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54270       };
54271     } catch (Dali::DaliException e) {
54272       {
54273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54274       };
54275     } catch (...) {
54276       {
54277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54278       };
54279     }
54280   }
54281
54282 }
54283
54284
54285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
54286   void * jresult ;
54287   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
54288
54289   {
54290     try {
54291       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
54292     } catch (std::out_of_range& e) {
54293       {
54294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54295       };
54296     } catch (std::exception& e) {
54297       {
54298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54299       };
54300     } catch (Dali::DaliException e) {
54301       {
54302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54303       };
54304     } catch (...) {
54305       {
54306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54307       };
54308     }
54309   }
54310
54311   jresult = (void *)result;
54312   return jresult;
54313 }
54314
54315
54316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
54317   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54318
54319   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54320   {
54321     try {
54322       delete arg1;
54323     } catch (std::out_of_range& e) {
54324       {
54325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54326       };
54327     } catch (std::exception& e) {
54328       {
54329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54330       };
54331     } catch (Dali::DaliException e) {
54332       {
54333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54334       };
54335     } catch (...) {
54336       {
54337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54338       };
54339     }
54340   }
54341
54342 }
54343
54344
54345 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
54346   unsigned int jresult ;
54347   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54348   bool result;
54349
54350   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54351   {
54352     try {
54353       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54354     } catch (std::out_of_range& e) {
54355       {
54356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54357       };
54358     } catch (std::exception& e) {
54359       {
54360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54361       };
54362     } catch (Dali::DaliException e) {
54363       {
54364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54365       };
54366     } catch (...) {
54367       {
54368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54369       };
54370     }
54371   }
54372
54373   jresult = result;
54374   return jresult;
54375 }
54376
54377
54378 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
54379   unsigned long jresult ;
54380   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54381   std::size_t result;
54382
54383   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54384   {
54385     try {
54386       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54387     } catch (std::out_of_range& e) {
54388       {
54389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54390       };
54391     } catch (std::exception& e) {
54392       {
54393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54394       };
54395     } catch (Dali::DaliException e) {
54396       {
54397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54398       };
54399     } catch (...) {
54400       {
54401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54402       };
54403     }
54404   }
54405
54406   jresult = (unsigned long)result;
54407   return jresult;
54408 }
54409
54410
54411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
54412   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54413   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54414
54415   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54416   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54417   {
54418     try {
54419       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
54420     } catch (std::out_of_range& e) {
54421       {
54422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54423       };
54424     } catch (std::exception& e) {
54425       {
54426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54427       };
54428     } catch (Dali::DaliException e) {
54429       {
54430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54431       };
54432     } catch (...) {
54433       {
54434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54435       };
54436     }
54437   }
54438
54439 }
54440
54441
54442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
54443   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54444   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54445
54446   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54447   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54448   {
54449     try {
54450       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
54451     } catch (std::out_of_range& e) {
54452       {
54453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54454       };
54455     } catch (std::exception& e) {
54456       {
54457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54458       };
54459     } catch (Dali::DaliException e) {
54460       {
54461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54462       };
54463     } catch (...) {
54464       {
54465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54466       };
54467     }
54468   }
54469
54470 }
54471
54472
54473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
54474   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54475   Dali::PropertyNotification *arg2 = 0 ;
54476
54477   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54478   arg2 = (Dali::PropertyNotification *)jarg2;
54479   if (!arg2) {
54480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
54481     return ;
54482   }
54483   {
54484     try {
54485       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
54486     } catch (std::out_of_range& e) {
54487       {
54488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54489       };
54490     } catch (std::exception& e) {
54491       {
54492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54493       };
54494     } catch (Dali::DaliException e) {
54495       {
54496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54497       };
54498     } catch (...) {
54499       {
54500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54501       };
54502     }
54503   }
54504
54505 }
54506
54507
54508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
54509   void * jresult ;
54510   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
54511
54512   {
54513     try {
54514       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
54515     } catch (std::out_of_range& e) {
54516       {
54517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54518       };
54519     } catch (std::exception& e) {
54520       {
54521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54522       };
54523     } catch (Dali::DaliException e) {
54524       {
54525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54526       };
54527     } catch (...) {
54528       {
54529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54530       };
54531     }
54532   }
54533
54534   jresult = (void *)result;
54535   return jresult;
54536 }
54537
54538
54539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
54540   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54541
54542   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54543   {
54544     try {
54545       delete arg1;
54546     } catch (std::out_of_range& e) {
54547       {
54548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54549       };
54550     } catch (std::exception& e) {
54551       {
54552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54553       };
54554     } catch (Dali::DaliException e) {
54555       {
54556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54557       };
54558     } catch (...) {
54559       {
54560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54561       };
54562     }
54563   }
54564
54565 }
54566
54567
54568 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
54569   unsigned int jresult ;
54570   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54571   bool result;
54572
54573   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54574   {
54575     try {
54576       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
54577     } catch (std::out_of_range& e) {
54578       {
54579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54580       };
54581     } catch (std::exception& e) {
54582       {
54583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54584       };
54585     } catch (Dali::DaliException e) {
54586       {
54587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54588       };
54589     } catch (...) {
54590       {
54591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54592       };
54593     }
54594   }
54595
54596   jresult = result;
54597   return jresult;
54598 }
54599
54600
54601 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
54602   unsigned long jresult ;
54603   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54604   std::size_t result;
54605
54606   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54607   {
54608     try {
54609       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
54610     } catch (std::out_of_range& e) {
54611       {
54612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54613       };
54614     } catch (std::exception& e) {
54615       {
54616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54617       };
54618     } catch (Dali::DaliException e) {
54619       {
54620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54621       };
54622     } catch (...) {
54623       {
54624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54625       };
54626     }
54627   }
54628
54629   jresult = (unsigned long)result;
54630   return jresult;
54631 }
54632
54633
54634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
54635   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54636   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54637
54638   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54639   arg2 = (void (*)(Dali::Image))jarg2;
54640   {
54641     try {
54642       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
54643     } catch (std::out_of_range& e) {
54644       {
54645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54646       };
54647     } catch (std::exception& e) {
54648       {
54649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54650       };
54651     } catch (Dali::DaliException e) {
54652       {
54653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54654       };
54655     } catch (...) {
54656       {
54657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54658       };
54659     }
54660   }
54661
54662 }
54663
54664
54665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
54666   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54667   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54668
54669   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54670   arg2 = (void (*)(Dali::Image))jarg2;
54671   {
54672     try {
54673       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
54674     } catch (std::out_of_range& e) {
54675       {
54676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54677       };
54678     } catch (std::exception& e) {
54679       {
54680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54681       };
54682     } catch (Dali::DaliException e) {
54683       {
54684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54685       };
54686     } catch (...) {
54687       {
54688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54689       };
54690     }
54691   }
54692
54693 }
54694
54695
54696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
54697   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54698   Dali::Image arg2 ;
54699   Dali::Image *argp2 ;
54700
54701   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54702   argp2 = (Dali::Image *)jarg2;
54703   if (!argp2) {
54704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
54705     return ;
54706   }
54707   arg2 = *argp2;
54708   {
54709     try {
54710       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
54711     } catch (std::out_of_range& e) {
54712       {
54713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54714       };
54715     } catch (std::exception& e) {
54716       {
54717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54718       };
54719     } catch (Dali::DaliException e) {
54720       {
54721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54722       };
54723     } catch (...) {
54724       {
54725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54726       };
54727     }
54728   }
54729
54730 }
54731
54732
54733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
54734   void * jresult ;
54735   Dali::Signal< void (Dali::Image) > *result = 0 ;
54736
54737   {
54738     try {
54739       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
54740     } catch (std::out_of_range& e) {
54741       {
54742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54743       };
54744     } catch (std::exception& e) {
54745       {
54746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54747       };
54748     } catch (Dali::DaliException e) {
54749       {
54750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54751       };
54752     } catch (...) {
54753       {
54754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54755       };
54756     }
54757   }
54758
54759   jresult = (void *)result;
54760   return jresult;
54761 }
54762
54763
54764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
54765   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54766
54767   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54768   {
54769     try {
54770       delete arg1;
54771     } catch (std::out_of_range& e) {
54772       {
54773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54774       };
54775     } catch (std::exception& e) {
54776       {
54777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54778       };
54779     } catch (Dali::DaliException e) {
54780       {
54781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54782       };
54783     } catch (...) {
54784       {
54785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54786       };
54787     }
54788   }
54789
54790 }
54791
54792
54793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
54794   void * jresult ;
54795   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
54796
54797   {
54798     try {
54799       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
54800     } catch (std::out_of_range& e) {
54801       {
54802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54803       };
54804     } catch (std::exception& e) {
54805       {
54806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54807       };
54808     } catch (Dali::DaliException e) {
54809       {
54810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54811       };
54812     } catch (...) {
54813       {
54814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54815       };
54816     }
54817   }
54818
54819   jresult = (void *)result;
54820   return jresult;
54821 }
54822
54823
54824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
54825   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
54826
54827   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
54828   {
54829     try {
54830       delete arg1;
54831     } catch (std::out_of_range& e) {
54832       {
54833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54834       };
54835     } catch (std::exception& e) {
54836       {
54837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54838       };
54839     } catch (Dali::DaliException e) {
54840       {
54841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54842       };
54843     } catch (...) {
54844       {
54845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54846       };
54847     }
54848   }
54849
54850 }
54851
54852
54853 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
54854   unsigned int jresult ;
54855   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
54856   bool result;
54857
54858   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
54859   {
54860     try {
54861       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);
54862     } catch (std::out_of_range& e) {
54863       {
54864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54865       };
54866     } catch (std::exception& e) {
54867       {
54868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54869       };
54870     } catch (Dali::DaliException e) {
54871       {
54872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54873       };
54874     } catch (...) {
54875       {
54876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54877       };
54878     }
54879   }
54880
54881   jresult = result;
54882   return jresult;
54883 }
54884
54885
54886 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
54887   unsigned long jresult ;
54888   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
54889   std::size_t result;
54890
54891   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
54892   {
54893     try {
54894       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);
54895     } catch (std::out_of_range& e) {
54896       {
54897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54898       };
54899     } catch (std::exception& e) {
54900       {
54901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54902       };
54903     } catch (Dali::DaliException e) {
54904       {
54905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54906       };
54907     } catch (...) {
54908       {
54909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54910       };
54911     }
54912   }
54913
54914   jresult = (unsigned long)result;
54915   return jresult;
54916 }
54917
54918
54919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
54920   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
54921   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
54922
54923   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
54924   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
54925   {
54926     try {
54927       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
54928     } catch (std::out_of_range& e) {
54929       {
54930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54931       };
54932     } catch (std::exception& e) {
54933       {
54934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54935       };
54936     } catch (Dali::DaliException e) {
54937       {
54938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54939       };
54940     } catch (...) {
54941       {
54942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54943       };
54944     }
54945   }
54946
54947 }
54948
54949
54950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
54951   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
54952   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
54953
54954   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
54955   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
54956   {
54957     try {
54958       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
54959     } catch (std::out_of_range& e) {
54960       {
54961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54962       };
54963     } catch (std::exception& e) {
54964       {
54965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54966       };
54967     } catch (Dali::DaliException e) {
54968       {
54969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54970       };
54971     } catch (...) {
54972       {
54973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54974       };
54975     }
54976   }
54977
54978 }
54979
54980
54981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
54982   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
54983   Dali::Actor arg2 ;
54984   Dali::LongPressGesture *arg3 = 0 ;
54985   Dali::Actor *argp2 ;
54986
54987   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
54988   argp2 = (Dali::Actor *)jarg2;
54989   if (!argp2) {
54990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54991     return ;
54992   }
54993   arg2 = *argp2;
54994   arg3 = (Dali::LongPressGesture *)jarg3;
54995   if (!arg3) {
54996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
54997     return ;
54998   }
54999   {
55000     try {
55001       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
55002     } catch (std::out_of_range& e) {
55003       {
55004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55005       };
55006     } catch (std::exception& e) {
55007       {
55008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55009       };
55010     } catch (Dali::DaliException e) {
55011       {
55012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55013       };
55014     } catch (...) {
55015       {
55016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55017       };
55018     }
55019   }
55020
55021 }
55022
55023
55024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
55025   void * jresult ;
55026   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
55027
55028   {
55029     try {
55030       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
55031     } catch (std::out_of_range& e) {
55032       {
55033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55034       };
55035     } catch (std::exception& e) {
55036       {
55037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55038       };
55039     } catch (Dali::DaliException e) {
55040       {
55041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55042       };
55043     } catch (...) {
55044       {
55045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55046       };
55047     }
55048   }
55049
55050   jresult = (void *)result;
55051   return jresult;
55052 }
55053
55054
55055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
55056   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55057
55058   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55059   {
55060     try {
55061       delete arg1;
55062     } catch (std::out_of_range& e) {
55063       {
55064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55065       };
55066     } catch (std::exception& e) {
55067       {
55068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55069       };
55070     } catch (Dali::DaliException e) {
55071       {
55072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55073       };
55074     } catch (...) {
55075       {
55076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55077       };
55078     }
55079   }
55080
55081 }
55082
55083
55084 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
55085   unsigned int jresult ;
55086   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55087   bool result;
55088
55089   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55090   {
55091     try {
55092       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);
55093     } catch (std::out_of_range& e) {
55094       {
55095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55096       };
55097     } catch (std::exception& e) {
55098       {
55099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55100       };
55101     } catch (Dali::DaliException e) {
55102       {
55103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55104       };
55105     } catch (...) {
55106       {
55107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55108       };
55109     }
55110   }
55111
55112   jresult = result;
55113   return jresult;
55114 }
55115
55116
55117 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
55118   unsigned long jresult ;
55119   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55120   std::size_t result;
55121
55122   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55123   {
55124     try {
55125       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);
55126     } catch (std::out_of_range& e) {
55127       {
55128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55129       };
55130     } catch (std::exception& e) {
55131       {
55132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55133       };
55134     } catch (Dali::DaliException e) {
55135       {
55136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55137       };
55138     } catch (...) {
55139       {
55140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55141       };
55142     }
55143   }
55144
55145   jresult = (unsigned long)result;
55146   return jresult;
55147 }
55148
55149
55150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
55151   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55152   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55153
55154   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55155   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55156   {
55157     try {
55158       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55159     } catch (std::out_of_range& e) {
55160       {
55161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55162       };
55163     } catch (std::exception& e) {
55164       {
55165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55166       };
55167     } catch (Dali::DaliException e) {
55168       {
55169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55170       };
55171     } catch (...) {
55172       {
55173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55174       };
55175     }
55176   }
55177
55178 }
55179
55180
55181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
55182   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55183   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55184
55185   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55186   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55187   {
55188     try {
55189       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55190     } catch (std::out_of_range& e) {
55191       {
55192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55193       };
55194     } catch (std::exception& e) {
55195       {
55196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55197       };
55198     } catch (Dali::DaliException e) {
55199       {
55200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55201       };
55202     } catch (...) {
55203       {
55204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55205       };
55206     }
55207   }
55208
55209 }
55210
55211
55212 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55213   unsigned int jresult ;
55214   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55215   Dali::Actor arg2 ;
55216   Dali::TouchData *arg3 = 0 ;
55217   Dali::Actor *argp2 ;
55218   bool result;
55219
55220   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55221   argp2 = (Dali::Actor *)jarg2;
55222   if (!argp2) {
55223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55224     return 0;
55225   }
55226   arg2 = *argp2;
55227   arg3 = (Dali::TouchData *)jarg3;
55228   if (!arg3) {
55229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
55230     return 0;
55231   }
55232   {
55233     try {
55234       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
55235     } catch (std::out_of_range& e) {
55236       {
55237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55238       };
55239     } catch (std::exception& e) {
55240       {
55241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55242       };
55243     } catch (Dali::DaliException e) {
55244       {
55245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55246       };
55247     } catch (...) {
55248       {
55249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55250       };
55251     }
55252   }
55253
55254   jresult = result;
55255   return jresult;
55256 }
55257
55258
55259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
55260   void * jresult ;
55261   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
55262
55263   {
55264     try {
55265       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
55266     } catch (std::out_of_range& e) {
55267       {
55268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55269       };
55270     } catch (std::exception& e) {
55271       {
55272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55273       };
55274     } catch (Dali::DaliException e) {
55275       {
55276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55277       };
55278     } catch (...) {
55279       {
55280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55281       };
55282     }
55283   }
55284
55285   jresult = (void *)result;
55286   return jresult;
55287 }
55288
55289
55290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
55291   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55292
55293   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55294   {
55295     try {
55296       delete arg1;
55297     } catch (std::out_of_range& e) {
55298       {
55299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55300       };
55301     } catch (std::exception& e) {
55302       {
55303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55304       };
55305     } catch (Dali::DaliException e) {
55306       {
55307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55308       };
55309     } catch (...) {
55310       {
55311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55312       };
55313     }
55314   }
55315
55316 }
55317
55318
55319 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
55320   unsigned int jresult ;
55321   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55322   bool result;
55323
55324   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55325   {
55326     try {
55327       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);
55328     } catch (std::out_of_range& e) {
55329       {
55330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55331       };
55332     } catch (std::exception& e) {
55333       {
55334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55335       };
55336     } catch (Dali::DaliException e) {
55337       {
55338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55339       };
55340     } catch (...) {
55341       {
55342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55343       };
55344     }
55345   }
55346
55347   jresult = result;
55348   return jresult;
55349 }
55350
55351
55352 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
55353   unsigned long jresult ;
55354   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55355   std::size_t result;
55356
55357   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55358   {
55359     try {
55360       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);
55361     } catch (std::out_of_range& e) {
55362       {
55363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55364       };
55365     } catch (std::exception& e) {
55366       {
55367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55368       };
55369     } catch (Dali::DaliException e) {
55370       {
55371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55372       };
55373     } catch (...) {
55374       {
55375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55376       };
55377     }
55378   }
55379
55380   jresult = (unsigned long)result;
55381   return jresult;
55382 }
55383
55384
55385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
55386   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55387   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55388
55389   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55390   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55391   {
55392     try {
55393       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55394     } catch (std::out_of_range& e) {
55395       {
55396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55397       };
55398     } catch (std::exception& e) {
55399       {
55400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55401       };
55402     } catch (Dali::DaliException e) {
55403       {
55404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55405       };
55406     } catch (...) {
55407       {
55408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55409       };
55410     }
55411   }
55412
55413 }
55414
55415
55416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
55417   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55418   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55419
55420   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55421   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55422   {
55423     try {
55424       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55425     } catch (std::out_of_range& e) {
55426       {
55427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55428       };
55429     } catch (std::exception& e) {
55430       {
55431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55432       };
55433     } catch (Dali::DaliException e) {
55434       {
55435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55436       };
55437     } catch (...) {
55438       {
55439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55440       };
55441     }
55442   }
55443
55444 }
55445
55446
55447 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55448   unsigned int jresult ;
55449   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55450   Dali::Actor arg2 ;
55451   Dali::HoverEvent *arg3 = 0 ;
55452   Dali::Actor *argp2 ;
55453   bool result;
55454
55455   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55456   argp2 = (Dali::Actor *)jarg2;
55457   if (!argp2) {
55458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55459     return 0;
55460   }
55461   arg2 = *argp2;
55462   arg3 = (Dali::HoverEvent *)jarg3;
55463   if (!arg3) {
55464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
55465     return 0;
55466   }
55467   {
55468     try {
55469       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
55470     } catch (std::out_of_range& e) {
55471       {
55472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55473       };
55474     } catch (std::exception& e) {
55475       {
55476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55477       };
55478     } catch (Dali::DaliException e) {
55479       {
55480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55481       };
55482     } catch (...) {
55483       {
55484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55485       };
55486     }
55487   }
55488
55489   jresult = result;
55490   return jresult;
55491 }
55492
55493
55494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
55495   void * jresult ;
55496   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
55497
55498   {
55499     try {
55500       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
55501     } catch (std::out_of_range& e) {
55502       {
55503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55504       };
55505     } catch (std::exception& e) {
55506       {
55507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55508       };
55509     } catch (Dali::DaliException e) {
55510       {
55511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55512       };
55513     } catch (...) {
55514       {
55515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55516       };
55517     }
55518   }
55519
55520   jresult = (void *)result;
55521   return jresult;
55522 }
55523
55524
55525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
55526   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55527
55528   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55529   {
55530     try {
55531       delete arg1;
55532     } catch (std::out_of_range& e) {
55533       {
55534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55535       };
55536     } catch (std::exception& e) {
55537       {
55538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55539       };
55540     } catch (Dali::DaliException e) {
55541       {
55542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55543       };
55544     } catch (...) {
55545       {
55546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55547       };
55548     }
55549   }
55550
55551 }
55552
55553
55554 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
55555   unsigned int jresult ;
55556   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55557   bool result;
55558
55559   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55560   {
55561     try {
55562       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);
55563     } catch (std::out_of_range& e) {
55564       {
55565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55566       };
55567     } catch (std::exception& e) {
55568       {
55569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55570       };
55571     } catch (Dali::DaliException e) {
55572       {
55573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55574       };
55575     } catch (...) {
55576       {
55577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55578       };
55579     }
55580   }
55581
55582   jresult = result;
55583   return jresult;
55584 }
55585
55586
55587 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
55588   unsigned long jresult ;
55589   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55590   std::size_t result;
55591
55592   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55593   {
55594     try {
55595       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);
55596     } catch (std::out_of_range& e) {
55597       {
55598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55599       };
55600     } catch (std::exception& e) {
55601       {
55602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55603       };
55604     } catch (Dali::DaliException e) {
55605       {
55606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55607       };
55608     } catch (...) {
55609       {
55610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55611       };
55612     }
55613   }
55614
55615   jresult = (unsigned long)result;
55616   return jresult;
55617 }
55618
55619
55620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
55621   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55622   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55623
55624   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55625   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55626   {
55627     try {
55628       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55629     } catch (std::out_of_range& e) {
55630       {
55631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55632       };
55633     } catch (std::exception& e) {
55634       {
55635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55636       };
55637     } catch (Dali::DaliException e) {
55638       {
55639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55640       };
55641     } catch (...) {
55642       {
55643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55644       };
55645     }
55646   }
55647
55648 }
55649
55650
55651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
55652   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55653   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55654
55655   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55656   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55657   {
55658     try {
55659       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55660     } catch (std::out_of_range& e) {
55661       {
55662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55663       };
55664     } catch (std::exception& e) {
55665       {
55666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55667       };
55668     } catch (Dali::DaliException e) {
55669       {
55670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55671       };
55672     } catch (...) {
55673       {
55674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55675       };
55676     }
55677   }
55678
55679 }
55680
55681
55682 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55683   unsigned int jresult ;
55684   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55685   Dali::Actor arg2 ;
55686   Dali::WheelEvent *arg3 = 0 ;
55687   Dali::Actor *argp2 ;
55688   bool result;
55689
55690   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55691   argp2 = (Dali::Actor *)jarg2;
55692   if (!argp2) {
55693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55694     return 0;
55695   }
55696   arg2 = *argp2;
55697   arg3 = (Dali::WheelEvent *)jarg3;
55698   if (!arg3) {
55699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
55700     return 0;
55701   }
55702   {
55703     try {
55704       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
55705     } catch (std::out_of_range& e) {
55706       {
55707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55708       };
55709     } catch (std::exception& e) {
55710       {
55711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55712       };
55713     } catch (Dali::DaliException e) {
55714       {
55715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55716       };
55717     } catch (...) {
55718       {
55719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55720       };
55721     }
55722   }
55723
55724   jresult = result;
55725   return jresult;
55726 }
55727
55728
55729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
55730   void * jresult ;
55731   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
55732
55733   {
55734     try {
55735       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
55736     } catch (std::out_of_range& e) {
55737       {
55738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55739       };
55740     } catch (std::exception& e) {
55741       {
55742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55743       };
55744     } catch (Dali::DaliException e) {
55745       {
55746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55747       };
55748     } catch (...) {
55749       {
55750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55751       };
55752     }
55753   }
55754
55755   jresult = (void *)result;
55756   return jresult;
55757 }
55758
55759
55760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
55761   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55762
55763   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55764   {
55765     try {
55766       delete arg1;
55767     } catch (std::out_of_range& e) {
55768       {
55769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55770       };
55771     } catch (std::exception& e) {
55772       {
55773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55774       };
55775     } catch (Dali::DaliException e) {
55776       {
55777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55778       };
55779     } catch (...) {
55780       {
55781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55782       };
55783     }
55784   }
55785
55786 }
55787
55788
55789 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
55790   unsigned int jresult ;
55791   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
55792   bool result;
55793
55794   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
55795   {
55796     try {
55797       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
55798     } catch (std::out_of_range& e) {
55799       {
55800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55801       };
55802     } catch (std::exception& e) {
55803       {
55804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55805       };
55806     } catch (Dali::DaliException e) {
55807       {
55808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55809       };
55810     } catch (...) {
55811       {
55812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55813       };
55814     }
55815   }
55816
55817   jresult = result;
55818   return jresult;
55819 }
55820
55821
55822 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
55823   unsigned long jresult ;
55824   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
55825   std::size_t result;
55826
55827   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
55828   {
55829     try {
55830       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
55831     } catch (std::out_of_range& e) {
55832       {
55833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55834       };
55835     } catch (std::exception& e) {
55836       {
55837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55838       };
55839     } catch (Dali::DaliException e) {
55840       {
55841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55842       };
55843     } catch (...) {
55844       {
55845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55846       };
55847     }
55848   }
55849
55850   jresult = (unsigned long)result;
55851   return jresult;
55852 }
55853
55854
55855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
55856   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
55857   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
55858
55859   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
55860   arg2 = (void (*)(Dali::Actor))jarg2;
55861   {
55862     try {
55863       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
55864     } catch (std::out_of_range& e) {
55865       {
55866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55867       };
55868     } catch (std::exception& e) {
55869       {
55870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55871       };
55872     } catch (Dali::DaliException e) {
55873       {
55874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55875       };
55876     } catch (...) {
55877       {
55878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55879       };
55880     }
55881   }
55882
55883 }
55884
55885
55886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
55887   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
55888   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
55889
55890   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
55891   arg2 = (void (*)(Dali::Actor))jarg2;
55892   {
55893     try {
55894       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
55895     } catch (std::out_of_range& e) {
55896       {
55897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55898       };
55899     } catch (std::exception& e) {
55900       {
55901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55902       };
55903     } catch (Dali::DaliException e) {
55904       {
55905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55906       };
55907     } catch (...) {
55908       {
55909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55910       };
55911     }
55912   }
55913
55914 }
55915
55916
55917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
55918   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
55919   Dali::Actor arg2 ;
55920   Dali::Actor *argp2 ;
55921
55922   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
55923   argp2 = (Dali::Actor *)jarg2;
55924   if (!argp2) {
55925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55926     return ;
55927   }
55928   arg2 = *argp2;
55929   {
55930     try {
55931       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
55932     } catch (std::out_of_range& e) {
55933       {
55934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55935       };
55936     } catch (std::exception& e) {
55937       {
55938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55939       };
55940     } catch (Dali::DaliException e) {
55941       {
55942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55943       };
55944     } catch (...) {
55945       {
55946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55947       };
55948     }
55949   }
55950
55951 }
55952
55953
55954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
55955   void * jresult ;
55956   Dali::Signal< void (Dali::Actor) > *result = 0 ;
55957
55958   {
55959     try {
55960       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
55961     } catch (std::out_of_range& e) {
55962       {
55963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55964       };
55965     } catch (std::exception& e) {
55966       {
55967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55968       };
55969     } catch (Dali::DaliException e) {
55970       {
55971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55972       };
55973     } catch (...) {
55974       {
55975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55976       };
55977     }
55978   }
55979
55980   jresult = (void *)result;
55981   return jresult;
55982 }
55983
55984
55985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
55986   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
55987
55988   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
55989   {
55990     try {
55991       delete arg1;
55992     } catch (std::out_of_range& e) {
55993       {
55994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55995       };
55996     } catch (std::exception& e) {
55997       {
55998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55999       };
56000     } catch (Dali::DaliException e) {
56001       {
56002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56003       };
56004     } catch (...) {
56005       {
56006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56007       };
56008     }
56009   }
56010
56011 }
56012
56013
56014 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
56015   unsigned int jresult ;
56016   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56017   bool result;
56018
56019   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56020   {
56021     try {
56022       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56023     } catch (std::out_of_range& e) {
56024       {
56025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56026       };
56027     } catch (std::exception& e) {
56028       {
56029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56030       };
56031     } catch (Dali::DaliException e) {
56032       {
56033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56034       };
56035     } catch (...) {
56036       {
56037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56038       };
56039     }
56040   }
56041
56042   jresult = result;
56043   return jresult;
56044 }
56045
56046
56047 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
56048   unsigned long jresult ;
56049   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56050   std::size_t result;
56051
56052   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56053   {
56054     try {
56055       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56056     } catch (std::out_of_range& e) {
56057       {
56058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56059       };
56060     } catch (std::exception& e) {
56061       {
56062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56063       };
56064     } catch (Dali::DaliException e) {
56065       {
56066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56067       };
56068     } catch (...) {
56069       {
56070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56071       };
56072     }
56073   }
56074
56075   jresult = (unsigned long)result;
56076   return jresult;
56077 }
56078
56079
56080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
56081   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56082   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56083
56084   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56085   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56086   {
56087     try {
56088       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56089     } catch (std::out_of_range& e) {
56090       {
56091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56092       };
56093     } catch (std::exception& e) {
56094       {
56095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56096       };
56097     } catch (Dali::DaliException e) {
56098       {
56099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56100       };
56101     } catch (...) {
56102       {
56103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56104       };
56105     }
56106   }
56107
56108 }
56109
56110
56111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
56112   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56113   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56114
56115   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56116   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56117   {
56118     try {
56119       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56120     } catch (std::out_of_range& e) {
56121       {
56122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56123       };
56124     } catch (std::exception& e) {
56125       {
56126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56127       };
56128     } catch (Dali::DaliException e) {
56129       {
56130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56131       };
56132     } catch (...) {
56133       {
56134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56135       };
56136     }
56137   }
56138
56139 }
56140
56141
56142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
56143   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56144   Dali::KeyEvent *arg2 = 0 ;
56145
56146   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56147   arg2 = (Dali::KeyEvent *)jarg2;
56148   if (!arg2) {
56149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56150     return ;
56151   }
56152   {
56153     try {
56154       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
56155     } catch (std::out_of_range& e) {
56156       {
56157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56158       };
56159     } catch (std::exception& e) {
56160       {
56161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56162       };
56163     } catch (Dali::DaliException e) {
56164       {
56165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56166       };
56167     } catch (...) {
56168       {
56169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56170       };
56171     }
56172   }
56173
56174 }
56175
56176
56177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
56178   void * jresult ;
56179   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
56180
56181   {
56182     try {
56183       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
56184     } catch (std::out_of_range& e) {
56185       {
56186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56187       };
56188     } catch (std::exception& e) {
56189       {
56190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56191       };
56192     } catch (Dali::DaliException e) {
56193       {
56194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56195       };
56196     } catch (...) {
56197       {
56198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56199       };
56200     }
56201   }
56202
56203   jresult = (void *)result;
56204   return jresult;
56205 }
56206
56207
56208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
56209   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56210
56211   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56212   {
56213     try {
56214       delete arg1;
56215     } catch (std::out_of_range& e) {
56216       {
56217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56218       };
56219     } catch (std::exception& e) {
56220       {
56221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56222       };
56223     } catch (Dali::DaliException e) {
56224       {
56225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56226       };
56227     } catch (...) {
56228       {
56229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56230       };
56231     }
56232   }
56233
56234 }
56235
56236
56237 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
56238   unsigned int jresult ;
56239   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56240   bool result;
56241
56242   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56243   {
56244     try {
56245       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56246     } catch (std::out_of_range& e) {
56247       {
56248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56249       };
56250     } catch (std::exception& e) {
56251       {
56252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56253       };
56254     } catch (Dali::DaliException e) {
56255       {
56256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56257       };
56258     } catch (...) {
56259       {
56260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56261       };
56262     }
56263   }
56264
56265   jresult = result;
56266   return jresult;
56267 }
56268
56269
56270 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
56271   unsigned long jresult ;
56272   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56273   std::size_t result;
56274
56275   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56276   {
56277     try {
56278       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56279     } catch (std::out_of_range& e) {
56280       {
56281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56282       };
56283     } catch (std::exception& e) {
56284       {
56285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56286       };
56287     } catch (Dali::DaliException e) {
56288       {
56289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56290       };
56291     } catch (...) {
56292       {
56293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56294       };
56295     }
56296   }
56297
56298   jresult = (unsigned long)result;
56299   return jresult;
56300 }
56301
56302
56303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
56304   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56305   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56306
56307   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56308   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56309   {
56310     try {
56311       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56312     } catch (std::out_of_range& e) {
56313       {
56314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56315       };
56316     } catch (std::exception& e) {
56317       {
56318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56319       };
56320     } catch (Dali::DaliException e) {
56321       {
56322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56323       };
56324     } catch (...) {
56325       {
56326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56327       };
56328     }
56329   }
56330
56331 }
56332
56333
56334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
56335   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56336   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56337
56338   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56339   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56340   {
56341     try {
56342       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56343     } catch (std::out_of_range& e) {
56344       {
56345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56346       };
56347     } catch (std::exception& e) {
56348       {
56349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56350       };
56351     } catch (Dali::DaliException e) {
56352       {
56353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56354       };
56355     } catch (...) {
56356       {
56357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56358       };
56359     }
56360   }
56361
56362 }
56363
56364
56365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
56366   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56367   Dali::TouchData *arg2 = 0 ;
56368
56369   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56370   arg2 = (Dali::TouchData *)jarg2;
56371   if (!arg2) {
56372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
56373     return ;
56374   }
56375   {
56376     try {
56377       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
56378     } catch (std::out_of_range& e) {
56379       {
56380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56381       };
56382     } catch (std::exception& e) {
56383       {
56384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56385       };
56386     } catch (Dali::DaliException e) {
56387       {
56388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56389       };
56390     } catch (...) {
56391       {
56392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56393       };
56394     }
56395   }
56396
56397 }
56398
56399
56400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
56401   void * jresult ;
56402   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
56403
56404   {
56405     try {
56406       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
56407     } catch (std::out_of_range& e) {
56408       {
56409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56410       };
56411     } catch (std::exception& e) {
56412       {
56413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56414       };
56415     } catch (Dali::DaliException e) {
56416       {
56417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56418       };
56419     } catch (...) {
56420       {
56421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56422       };
56423     }
56424   }
56425
56426   jresult = (void *)result;
56427   return jresult;
56428 }
56429
56430
56431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
56432   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56433
56434   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56435   {
56436     try {
56437       delete arg1;
56438     } catch (std::out_of_range& e) {
56439       {
56440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56441       };
56442     } catch (std::exception& e) {
56443       {
56444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56445       };
56446     } catch (Dali::DaliException e) {
56447       {
56448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56449       };
56450     } catch (...) {
56451       {
56452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56453       };
56454     }
56455   }
56456
56457 }
56458
56459
56460 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
56461   unsigned int jresult ;
56462   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56463   bool result;
56464
56465   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56466   {
56467     try {
56468       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56469     } catch (std::out_of_range& e) {
56470       {
56471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56472       };
56473     } catch (std::exception& e) {
56474       {
56475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56476       };
56477     } catch (Dali::DaliException e) {
56478       {
56479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56480       };
56481     } catch (...) {
56482       {
56483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56484       };
56485     }
56486   }
56487
56488   jresult = result;
56489   return jresult;
56490 }
56491
56492
56493 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
56494   unsigned long jresult ;
56495   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56496   std::size_t result;
56497
56498   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56499   {
56500     try {
56501       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56502     } catch (std::out_of_range& e) {
56503       {
56504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56505       };
56506     } catch (std::exception& e) {
56507       {
56508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56509       };
56510     } catch (Dali::DaliException e) {
56511       {
56512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56513       };
56514     } catch (...) {
56515       {
56516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56517       };
56518     }
56519   }
56520
56521   jresult = (unsigned long)result;
56522   return jresult;
56523 }
56524
56525
56526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
56527   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56528   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56529
56530   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56531   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56532   {
56533     try {
56534       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56535     } catch (std::out_of_range& e) {
56536       {
56537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56538       };
56539     } catch (std::exception& e) {
56540       {
56541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56542       };
56543     } catch (Dali::DaliException e) {
56544       {
56545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56546       };
56547     } catch (...) {
56548       {
56549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56550       };
56551     }
56552   }
56553
56554 }
56555
56556
56557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
56558   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56559   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56560
56561   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56562   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56563   {
56564     try {
56565       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56566     } catch (std::out_of_range& e) {
56567       {
56568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56569       };
56570     } catch (std::exception& e) {
56571       {
56572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56573       };
56574     } catch (Dali::DaliException e) {
56575       {
56576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56577       };
56578     } catch (...) {
56579       {
56580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56581       };
56582     }
56583   }
56584
56585 }
56586
56587
56588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
56589   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56590   Dali::WheelEvent *arg2 = 0 ;
56591
56592   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56593   arg2 = (Dali::WheelEvent *)jarg2;
56594   if (!arg2) {
56595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56596     return ;
56597   }
56598   {
56599     try {
56600       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
56601     } catch (std::out_of_range& e) {
56602       {
56603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56604       };
56605     } catch (std::exception& e) {
56606       {
56607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56608       };
56609     } catch (Dali::DaliException e) {
56610       {
56611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56612       };
56613     } catch (...) {
56614       {
56615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56616       };
56617     }
56618   }
56619
56620 }
56621
56622
56623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
56624   void * jresult ;
56625   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
56626
56627   {
56628     try {
56629       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
56630     } catch (std::out_of_range& e) {
56631       {
56632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56633       };
56634     } catch (std::exception& e) {
56635       {
56636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56637       };
56638     } catch (Dali::DaliException e) {
56639       {
56640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56641       };
56642     } catch (...) {
56643       {
56644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56645       };
56646     }
56647   }
56648
56649   jresult = (void *)result;
56650   return jresult;
56651 }
56652
56653
56654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
56655   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56656
56657   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56658   {
56659     try {
56660       delete arg1;
56661     } catch (std::out_of_range& e) {
56662       {
56663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56664       };
56665     } catch (std::exception& e) {
56666       {
56667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56668       };
56669     } catch (Dali::DaliException e) {
56670       {
56671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56672       };
56673     } catch (...) {
56674       {
56675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56676       };
56677     }
56678   }
56679
56680 }
56681
56682
56683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
56684   void * jresult ;
56685   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56686
56687   {
56688     try {
56689       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
56690     } catch (std::out_of_range& e) {
56691       {
56692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56693       };
56694     } catch (std::exception& e) {
56695       {
56696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56697       };
56698     } catch (Dali::DaliException e) {
56699       {
56700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56701       };
56702     } catch (...) {
56703       {
56704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56705       };
56706     }
56707   }
56708
56709   jresult = (void *)result;
56710   return jresult;
56711 }
56712
56713
56714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
56715   void * jresult ;
56716   Dali::Radian arg1 ;
56717   Dali::Radian arg2 ;
56718   Dali::Radian *argp1 ;
56719   Dali::Radian *argp2 ;
56720   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56721
56722   argp1 = (Dali::Radian *)jarg1;
56723   if (!argp1) {
56724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56725     return 0;
56726   }
56727   arg1 = *argp1;
56728   argp2 = (Dali::Radian *)jarg2;
56729   if (!argp2) {
56730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56731     return 0;
56732   }
56733   arg2 = *argp2;
56734   {
56735     try {
56736       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
56737     } catch (std::out_of_range& e) {
56738       {
56739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56740       };
56741     } catch (std::exception& e) {
56742       {
56743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56744       };
56745     } catch (Dali::DaliException e) {
56746       {
56747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56748       };
56749     } catch (...) {
56750       {
56751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56752       };
56753     }
56754   }
56755
56756   jresult = (void *)result;
56757   return jresult;
56758 }
56759
56760
56761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
56762   void * jresult ;
56763   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
56764   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56765
56766   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56767   if (!arg1) {
56768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
56769     return 0;
56770   }
56771   {
56772     try {
56773       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
56774     } catch (std::out_of_range& e) {
56775       {
56776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56777       };
56778     } catch (std::exception& e) {
56779       {
56780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56781       };
56782     } catch (Dali::DaliException e) {
56783       {
56784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56785       };
56786     } catch (...) {
56787       {
56788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56789       };
56790     }
56791   }
56792
56793   jresult = (void *)result;
56794   return jresult;
56795 }
56796
56797
56798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
56799   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56800   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
56801
56802   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56803   arg2 = (Dali::Radian *)jarg2;
56804   if (arg1) (arg1)->first = *arg2;
56805 }
56806
56807
56808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
56809   void * jresult ;
56810   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56811   Dali::Radian *result = 0 ;
56812
56813   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56814   result = (Dali::Radian *)& ((arg1)->first);
56815   jresult = (void *)result;
56816   return jresult;
56817 }
56818
56819
56820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
56821   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56822   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
56823
56824   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56825   arg2 = (Dali::Radian *)jarg2;
56826   if (arg1) (arg1)->second = *arg2;
56827 }
56828
56829
56830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
56831   void * jresult ;
56832   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56833   Dali::Radian *result = 0 ;
56834
56835   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56836   result = (Dali::Radian *)& ((arg1)->second);
56837   jresult = (void *)result;
56838   return jresult;
56839 }
56840
56841
56842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
56843   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56844
56845   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56846   {
56847     try {
56848       delete arg1;
56849     } catch (std::out_of_range& e) {
56850       {
56851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56852       };
56853     } catch (std::exception& e) {
56854       {
56855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56856       };
56857     } catch (Dali::DaliException e) {
56858       {
56859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56860       };
56861     } catch (...) {
56862       {
56863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56864       };
56865     }
56866   }
56867
56868 }
56869
56870
56871 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
56872   unsigned int jresult ;
56873   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
56874   bool result;
56875
56876   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
56877   {
56878     try {
56879       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);
56880     } catch (std::out_of_range& e) {
56881       {
56882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56883       };
56884     } catch (std::exception& e) {
56885       {
56886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56887       };
56888     } catch (Dali::DaliException e) {
56889       {
56890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56891       };
56892     } catch (...) {
56893       {
56894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56895       };
56896     }
56897   }
56898
56899   jresult = result;
56900   return jresult;
56901 }
56902
56903
56904 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
56905   unsigned long jresult ;
56906   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
56907   std::size_t result;
56908
56909   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
56910   {
56911     try {
56912       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);
56913     } catch (std::out_of_range& e) {
56914       {
56915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56916       };
56917     } catch (std::exception& e) {
56918       {
56919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56920       };
56921     } catch (Dali::DaliException e) {
56922       {
56923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56924       };
56925     } catch (...) {
56926       {
56927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56928       };
56929     }
56930   }
56931
56932   jresult = (unsigned long)result;
56933   return jresult;
56934 }
56935
56936
56937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
56938   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
56939   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
56940
56941   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
56942   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
56943   {
56944     try {
56945       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56946     } catch (std::out_of_range& e) {
56947       {
56948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56949       };
56950     } catch (std::exception& e) {
56951       {
56952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56953       };
56954     } catch (Dali::DaliException e) {
56955       {
56956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56957       };
56958     } catch (...) {
56959       {
56960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56961       };
56962     }
56963   }
56964
56965 }
56966
56967
56968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
56969   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
56970   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
56971
56972   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
56973   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
56974   {
56975     try {
56976       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56977     } catch (std::out_of_range& e) {
56978       {
56979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56980       };
56981     } catch (std::exception& e) {
56982       {
56983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56984       };
56985     } catch (Dali::DaliException e) {
56986       {
56987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56988       };
56989     } catch (...) {
56990       {
56991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56992       };
56993     }
56994   }
56995
56996 }
56997
56998
56999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57000   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57001   Dali::Actor arg2 ;
57002   Dali::PanGesture *arg3 = 0 ;
57003   Dali::Actor *argp2 ;
57004
57005   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57006   argp2 = (Dali::Actor *)jarg2;
57007   if (!argp2) {
57008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57009     return ;
57010   }
57011   arg2 = *argp2;
57012   arg3 = (Dali::PanGesture *)jarg3;
57013   if (!arg3) {
57014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
57015     return ;
57016   }
57017   {
57018     try {
57019       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
57020     } catch (std::out_of_range& e) {
57021       {
57022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57023       };
57024     } catch (std::exception& e) {
57025       {
57026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57027       };
57028     } catch (Dali::DaliException e) {
57029       {
57030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57031       };
57032     } catch (...) {
57033       {
57034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57035       };
57036     }
57037   }
57038
57039 }
57040
57041
57042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
57043   void * jresult ;
57044   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
57045
57046   {
57047     try {
57048       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
57049     } catch (std::out_of_range& e) {
57050       {
57051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57052       };
57053     } catch (std::exception& e) {
57054       {
57055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57056       };
57057     } catch (Dali::DaliException e) {
57058       {
57059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57060       };
57061     } catch (...) {
57062       {
57063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57064       };
57065     }
57066   }
57067
57068   jresult = (void *)result;
57069   return jresult;
57070 }
57071
57072
57073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
57074   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57075
57076   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57077   {
57078     try {
57079       delete arg1;
57080     } catch (std::out_of_range& e) {
57081       {
57082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57083       };
57084     } catch (std::exception& e) {
57085       {
57086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57087       };
57088     } catch (Dali::DaliException e) {
57089       {
57090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57091       };
57092     } catch (...) {
57093       {
57094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57095       };
57096     }
57097   }
57098
57099 }
57100
57101
57102 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
57103   unsigned int jresult ;
57104   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57105   bool result;
57106
57107   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57108   {
57109     try {
57110       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);
57111     } catch (std::out_of_range& e) {
57112       {
57113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57114       };
57115     } catch (std::exception& e) {
57116       {
57117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57118       };
57119     } catch (Dali::DaliException e) {
57120       {
57121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57122       };
57123     } catch (...) {
57124       {
57125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57126       };
57127     }
57128   }
57129
57130   jresult = result;
57131   return jresult;
57132 }
57133
57134
57135 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57136   unsigned long jresult ;
57137   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57138   std::size_t result;
57139
57140   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57141   {
57142     try {
57143       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);
57144     } catch (std::out_of_range& e) {
57145       {
57146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57147       };
57148     } catch (std::exception& e) {
57149       {
57150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57151       };
57152     } catch (Dali::DaliException e) {
57153       {
57154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57155       };
57156     } catch (...) {
57157       {
57158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57159       };
57160     }
57161   }
57162
57163   jresult = (unsigned long)result;
57164   return jresult;
57165 }
57166
57167
57168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57169   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57170   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57171
57172   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57173   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57174   {
57175     try {
57176       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57177     } catch (std::out_of_range& e) {
57178       {
57179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57180       };
57181     } catch (std::exception& e) {
57182       {
57183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57184       };
57185     } catch (Dali::DaliException e) {
57186       {
57187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57188       };
57189     } catch (...) {
57190       {
57191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57192       };
57193     }
57194   }
57195
57196 }
57197
57198
57199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57200   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57201   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57202
57203   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57204   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57205   {
57206     try {
57207       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57208     } catch (std::out_of_range& e) {
57209       {
57210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57211       };
57212     } catch (std::exception& e) {
57213       {
57214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57215       };
57216     } catch (Dali::DaliException e) {
57217       {
57218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57219       };
57220     } catch (...) {
57221       {
57222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57223       };
57224     }
57225   }
57226
57227 }
57228
57229
57230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57231   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57232   Dali::Actor arg2 ;
57233   Dali::PinchGesture *arg3 = 0 ;
57234   Dali::Actor *argp2 ;
57235
57236   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57237   argp2 = (Dali::Actor *)jarg2;
57238   if (!argp2) {
57239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57240     return ;
57241   }
57242   arg2 = *argp2;
57243   arg3 = (Dali::PinchGesture *)jarg3;
57244   if (!arg3) {
57245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
57246     return ;
57247   }
57248   {
57249     try {
57250       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
57251     } catch (std::out_of_range& e) {
57252       {
57253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57254       };
57255     } catch (std::exception& e) {
57256       {
57257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57258       };
57259     } catch (Dali::DaliException e) {
57260       {
57261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57262       };
57263     } catch (...) {
57264       {
57265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57266       };
57267     }
57268   }
57269
57270 }
57271
57272
57273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
57274   void * jresult ;
57275   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
57276
57277   {
57278     try {
57279       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
57280     } catch (std::out_of_range& e) {
57281       {
57282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57283       };
57284     } catch (std::exception& e) {
57285       {
57286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57287       };
57288     } catch (Dali::DaliException e) {
57289       {
57290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57291       };
57292     } catch (...) {
57293       {
57294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57295       };
57296     }
57297   }
57298
57299   jresult = (void *)result;
57300   return jresult;
57301 }
57302
57303
57304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
57305   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57306
57307   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57308   {
57309     try {
57310       delete arg1;
57311     } catch (std::out_of_range& e) {
57312       {
57313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57314       };
57315     } catch (std::exception& e) {
57316       {
57317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57318       };
57319     } catch (Dali::DaliException e) {
57320       {
57321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57322       };
57323     } catch (...) {
57324       {
57325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57326       };
57327     }
57328   }
57329
57330 }
57331
57332
57333 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
57334   unsigned int jresult ;
57335   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57336   bool result;
57337
57338   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57339   {
57340     try {
57341       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);
57342     } catch (std::out_of_range& e) {
57343       {
57344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57345       };
57346     } catch (std::exception& e) {
57347       {
57348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57349       };
57350     } catch (Dali::DaliException e) {
57351       {
57352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57353       };
57354     } catch (...) {
57355       {
57356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57357       };
57358     }
57359   }
57360
57361   jresult = result;
57362   return jresult;
57363 }
57364
57365
57366 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57367   unsigned long jresult ;
57368   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57369   std::size_t result;
57370
57371   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57372   {
57373     try {
57374       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);
57375     } catch (std::out_of_range& e) {
57376       {
57377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57378       };
57379     } catch (std::exception& e) {
57380       {
57381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57382       };
57383     } catch (Dali::DaliException e) {
57384       {
57385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57386       };
57387     } catch (...) {
57388       {
57389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57390       };
57391     }
57392   }
57393
57394   jresult = (unsigned long)result;
57395   return jresult;
57396 }
57397
57398
57399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57400   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57401   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57402
57403   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57404   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57405   {
57406     try {
57407       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57408     } catch (std::out_of_range& e) {
57409       {
57410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57411       };
57412     } catch (std::exception& e) {
57413       {
57414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57415       };
57416     } catch (Dali::DaliException e) {
57417       {
57418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57419       };
57420     } catch (...) {
57421       {
57422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57423       };
57424     }
57425   }
57426
57427 }
57428
57429
57430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57431   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57432   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57433
57434   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57435   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57436   {
57437     try {
57438       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57439     } catch (std::out_of_range& e) {
57440       {
57441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57442       };
57443     } catch (std::exception& e) {
57444       {
57445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57446       };
57447     } catch (Dali::DaliException e) {
57448       {
57449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57450       };
57451     } catch (...) {
57452       {
57453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57454       };
57455     }
57456   }
57457
57458 }
57459
57460
57461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57462   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57463   Dali::Actor arg2 ;
57464   Dali::TapGesture *arg3 = 0 ;
57465   Dali::Actor *argp2 ;
57466
57467   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57468   argp2 = (Dali::Actor *)jarg2;
57469   if (!argp2) {
57470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57471     return ;
57472   }
57473   arg2 = *argp2;
57474   arg3 = (Dali::TapGesture *)jarg3;
57475   if (!arg3) {
57476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
57477     return ;
57478   }
57479   {
57480     try {
57481       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
57482     } catch (std::out_of_range& e) {
57483       {
57484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57485       };
57486     } catch (std::exception& e) {
57487       {
57488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57489       };
57490     } catch (Dali::DaliException e) {
57491       {
57492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57493       };
57494     } catch (...) {
57495       {
57496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57497       };
57498     }
57499   }
57500
57501 }
57502
57503
57504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
57505   void * jresult ;
57506   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
57507
57508   {
57509     try {
57510       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
57511     } catch (std::out_of_range& e) {
57512       {
57513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57514       };
57515     } catch (std::exception& e) {
57516       {
57517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57518       };
57519     } catch (Dali::DaliException e) {
57520       {
57521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57522       };
57523     } catch (...) {
57524       {
57525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57526       };
57527     }
57528   }
57529
57530   jresult = (void *)result;
57531   return jresult;
57532 }
57533
57534
57535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
57536   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57537
57538   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57539   {
57540     try {
57541       delete arg1;
57542     } catch (std::out_of_range& e) {
57543       {
57544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57545       };
57546     } catch (std::exception& e) {
57547       {
57548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57549       };
57550     } catch (Dali::DaliException e) {
57551       {
57552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57553       };
57554     } catch (...) {
57555       {
57556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57557       };
57558     }
57559   }
57560
57561 }
57562
57563 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
57564   unsigned int jresult ;
57565   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57566   bool result;
57567
57568   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57569   {
57570     try {
57571       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57572     } catch (std::out_of_range& e) {
57573       {
57574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57575       };
57576     } catch (std::exception& e) {
57577       {
57578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57579       };
57580     } catch (Dali::DaliException e) {
57581       {
57582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57583       };
57584     } catch (...) {
57585       {
57586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57587       };
57588     }
57589   }
57590
57591   jresult = result;
57592   return jresult;
57593 }
57594
57595
57596 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
57597   unsigned long jresult ;
57598   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57599   std::size_t result;
57600
57601   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57602   {
57603     try {
57604       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57605     } catch (std::out_of_range& e) {
57606       {
57607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57608       };
57609     } catch (std::exception& e) {
57610       {
57611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57612       };
57613     } catch (Dali::DaliException e) {
57614       {
57615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57616       };
57617     } catch (...) {
57618       {
57619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57620       };
57621     }
57622   }
57623
57624   jresult = (unsigned long)result;
57625   return jresult;
57626 }
57627
57628
57629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
57630   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57631   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57632
57633   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57634   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57635   {
57636     try {
57637       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
57638     } catch (std::out_of_range& e) {
57639       {
57640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57641       };
57642     } catch (std::exception& e) {
57643       {
57644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57645       };
57646     } catch (Dali::DaliException e) {
57647       {
57648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57649       };
57650     } catch (...) {
57651       {
57652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57653       };
57654     }
57655   }
57656
57657 }
57658
57659
57660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
57661   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57662   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57663
57664   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57665   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57666   {
57667     try {
57668       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
57669     } catch (std::out_of_range& e) {
57670       {
57671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57672       };
57673     } catch (std::exception& e) {
57674       {
57675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57676       };
57677     } catch (Dali::DaliException e) {
57678       {
57679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57680       };
57681     } catch (...) {
57682       {
57683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57684       };
57685     }
57686   }
57687
57688 }
57689
57690
57691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
57692   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57693   Dali::ResourceImage arg2 ;
57694   Dali::ResourceImage *argp2 ;
57695
57696   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57697   argp2 = (Dali::ResourceImage *)jarg2;
57698   if (!argp2) {
57699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
57700     return ;
57701   }
57702   arg2 = *argp2;
57703   {
57704     try {
57705       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
57706     } catch (std::out_of_range& e) {
57707       {
57708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57709       };
57710     } catch (std::exception& e) {
57711       {
57712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57713       };
57714     } catch (Dali::DaliException e) {
57715       {
57716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57717       };
57718     } catch (...) {
57719       {
57720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57721       };
57722     }
57723   }
57724
57725 }
57726
57727
57728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
57729   void * jresult ;
57730   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
57731
57732   {
57733     try {
57734       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
57735     } catch (std::out_of_range& e) {
57736       {
57737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57738       };
57739     } catch (std::exception& e) {
57740       {
57741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57742       };
57743     } catch (Dali::DaliException e) {
57744       {
57745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57746       };
57747     } catch (...) {
57748       {
57749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57750       };
57751     }
57752   }
57753
57754   jresult = (void *)result;
57755   return jresult;
57756 }
57757
57758
57759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
57760   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57761
57762   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57763   {
57764     try {
57765       delete arg1;
57766     } catch (std::out_of_range& e) {
57767       {
57768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57769       };
57770     } catch (std::exception& e) {
57771       {
57772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57773       };
57774     } catch (Dali::DaliException e) {
57775       {
57776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57777       };
57778     } catch (...) {
57779       {
57780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57781       };
57782     }
57783   }
57784
57785 }
57786
57787 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
57788   unsigned int jresult ;
57789   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57790   bool result = false;
57791
57792   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57793   {
57794     try {
57795       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);
57796     } catch (std::out_of_range& e) {
57797       {
57798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57799       };
57800     } catch (std::exception& e) {
57801       {
57802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57803       };
57804     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
57805   }
57806   jresult = result;
57807   return jresult;
57808 }
57809
57810 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
57811   unsigned long jresult ;
57812   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57813   std::size_t result = 0;
57814
57815   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57816   {
57817     try {
57818       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);
57819     } catch (std::out_of_range& e) {
57820       {
57821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57822       };
57823     } catch (std::exception& e) {
57824       {
57825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57826       };
57827     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
57828   }
57829   jresult = (unsigned long)result;
57830   return jresult;
57831 }
57832
57833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
57834   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57835   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
57836
57837   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57838   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
57839   {
57840     try {
57841       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
57842     } catch (std::out_of_range& e) {
57843       {
57844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57845       };
57846     } catch (std::exception& e) {
57847       {
57848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57849       };
57850     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
57851   }
57852 }
57853
57854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
57855   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57856   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
57857
57858   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57859   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
57860   {
57861     try {
57862       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
57863     } catch (std::out_of_range& e) {
57864       {
57865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57866       };
57867     } catch (std::exception& e) {
57868       {
57869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57870       };
57871     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
57872   }
57873 }
57874
57875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
57876   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57877   Dali::Actor arg2 ;
57878   //bool arg3 ;
57879   Dali::LayoutDirection::Type arg4 ;
57880   Dali::Actor *argp2 ;
57881
57882   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57883   argp2 = (Dali::Actor *)jarg2;
57884   if (!argp2) {
57885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57886     return ;
57887   }
57888   arg2 = *argp2;
57889   //arg3 = jarg3 ? true : false;
57890   arg4 = (Dali::LayoutDirection::Type)jarg4;
57891   {
57892     try {
57893       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
57894     } catch (std::out_of_range& e) {
57895       {
57896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57897       };
57898     } catch (std::exception& e) {
57899       {
57900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57901       };
57902     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
57903   }
57904 }
57905
57906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
57907   void * jresult ;
57908   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
57909
57910   {
57911     try {
57912       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
57913     } catch (std::out_of_range& e) {
57914       {
57915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57916       };
57917     } catch (std::exception& e) {
57918       {
57919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57920       };
57921     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
57922   }
57923   jresult = (void *)result;
57924   return jresult;
57925 }
57926
57927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
57928   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57929
57930   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57931   {
57932     try {
57933       delete arg1;
57934     } catch (std::out_of_range& e) {
57935       {
57936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57937       };
57938     } catch (std::exception& e) {
57939       {
57940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57941       };
57942     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
57943   }
57944 }
57945
57946 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
57947   unsigned int jresult ;
57948   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
57949   bool result;
57950
57951   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
57952   {
57953     try {
57954       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);
57955     } catch (std::out_of_range& e) {
57956       {
57957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57958       };
57959     } catch (std::exception& e) {
57960       {
57961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57962       };
57963     } catch (Dali::DaliException e) {
57964       {
57965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57966       };
57967     } catch (...) {
57968       {
57969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57970       };
57971     }
57972   }
57973
57974   jresult = result;
57975   return jresult;
57976 }
57977
57978
57979 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
57980   unsigned long jresult ;
57981   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
57982   std::size_t result;
57983
57984   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
57985   {
57986     try {
57987       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);
57988     } catch (std::out_of_range& e) {
57989       {
57990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57991       };
57992     } catch (std::exception& e) {
57993       {
57994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57995       };
57996     } catch (Dali::DaliException e) {
57997       {
57998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57999       };
58000     } catch (...) {
58001       {
58002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58003       };
58004     }
58005   }
58006
58007   jresult = (unsigned long)result;
58008   return jresult;
58009 }
58010
58011
58012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
58013   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58014   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58015
58016   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58017   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58018   {
58019     try {
58020       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
58021     } catch (std::out_of_range& e) {
58022       {
58023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58024       };
58025     } catch (std::exception& e) {
58026       {
58027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58028       };
58029     } catch (Dali::DaliException e) {
58030       {
58031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58032       };
58033     } catch (...) {
58034       {
58035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58036       };
58037     }
58038   }
58039
58040 }
58041
58042
58043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
58044   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58045   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58046
58047   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58048   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58049   {
58050     try {
58051       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
58052     } catch (std::out_of_range& e) {
58053       {
58054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58055       };
58056     } catch (std::exception& e) {
58057       {
58058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58059       };
58060     } catch (Dali::DaliException e) {
58061       {
58062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58063       };
58064     } catch (...) {
58065       {
58066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58067       };
58068     }
58069   }
58070
58071 }
58072
58073
58074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
58075   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58076   Dali::Actor arg2 ;
58077   bool arg3 ;
58078   Dali::DevelActor::VisibilityChange::Type arg4 ;
58079   Dali::Actor *argp2 ;
58080
58081   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58082   argp2 = (Dali::Actor *)jarg2;
58083   if (!argp2) {
58084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58085     return ;
58086   }
58087   arg2 = *argp2;
58088   arg3 = jarg3 ? true : false;
58089   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
58090   {
58091     try {
58092       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
58093     } catch (std::out_of_range& e) {
58094       {
58095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58096       };
58097     } catch (std::exception& e) {
58098       {
58099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58100       };
58101     } catch (Dali::DaliException e) {
58102       {
58103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58104       };
58105     } catch (...) {
58106       {
58107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58108       };
58109     }
58110   }
58111
58112 }
58113
58114
58115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
58116   void * jresult ;
58117   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
58118
58119   {
58120     try {
58121       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
58122     } catch (std::out_of_range& e) {
58123       {
58124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58125       };
58126     } catch (std::exception& e) {
58127       {
58128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58129       };
58130     } catch (Dali::DaliException e) {
58131       {
58132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58133       };
58134     } catch (...) {
58135       {
58136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58137       };
58138     }
58139   }
58140
58141   jresult = (void *)result;
58142   return jresult;
58143 }
58144
58145
58146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
58147   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58148
58149   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58150   {
58151     try {
58152       delete arg1;
58153     } catch (std::out_of_range& e) {
58154       {
58155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58156       };
58157     } catch (std::exception& e) {
58158       {
58159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58160       };
58161     } catch (Dali::DaliException e) {
58162       {
58163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58164       };
58165     } catch (...) {
58166       {
58167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58168       };
58169     }
58170   }
58171
58172 }
58173
58174
58175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
58176   void * jresult ;
58177   Dali::Timer *result = 0 ;
58178
58179   {
58180     try {
58181       result = (Dali::Timer *)new Dali::Timer();
58182     } catch (std::out_of_range& e) {
58183       {
58184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58185       };
58186     } catch (std::exception& e) {
58187       {
58188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58189       };
58190     } catch (Dali::DaliException e) {
58191       {
58192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58193       };
58194     } catch (...) {
58195       {
58196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58197       };
58198     }
58199   }
58200
58201   jresult = (void *)result;
58202   return jresult;
58203 }
58204
58205
58206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
58207   void * jresult ;
58208   unsigned int arg1 ;
58209   Dali::Timer result;
58210
58211   arg1 = (unsigned int)jarg1;
58212   {
58213     try {
58214       result = Dali::Timer::New(arg1);
58215     } catch (std::out_of_range& e) {
58216       {
58217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58218       };
58219     } catch (std::exception& e) {
58220       {
58221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58222       };
58223     } catch (Dali::DaliException e) {
58224       {
58225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58226       };
58227     } catch (...) {
58228       {
58229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58230       };
58231     }
58232   }
58233
58234   jresult = new Dali::Timer((const Dali::Timer &)result);
58235   return jresult;
58236 }
58237
58238
58239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
58240   void * jresult ;
58241   Dali::Timer *arg1 = 0 ;
58242   Dali::Timer *result = 0 ;
58243
58244   arg1 = (Dali::Timer *)jarg1;
58245   if (!arg1) {
58246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58247     return 0;
58248   }
58249   {
58250     try {
58251       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
58252     } catch (std::out_of_range& e) {
58253       {
58254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58255       };
58256     } catch (std::exception& e) {
58257       {
58258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58259       };
58260     } catch (Dali::DaliException e) {
58261       {
58262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58263       };
58264     } catch (...) {
58265       {
58266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58267       };
58268     }
58269   }
58270
58271   jresult = (void *)result;
58272   return jresult;
58273 }
58274
58275
58276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
58277   void * jresult ;
58278   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58279   Dali::Timer *arg2 = 0 ;
58280   Dali::Timer *result = 0 ;
58281
58282   arg1 = (Dali::Timer *)jarg1;
58283   arg2 = (Dali::Timer *)jarg2;
58284   if (!arg2) {
58285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58286     return 0;
58287   }
58288   {
58289     try {
58290       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
58291     } catch (std::out_of_range& e) {
58292       {
58293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58294       };
58295     } catch (std::exception& e) {
58296       {
58297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58298       };
58299     } catch (Dali::DaliException e) {
58300       {
58301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58302       };
58303     } catch (...) {
58304       {
58305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58306       };
58307     }
58308   }
58309
58310   jresult = (void *)result;
58311   return jresult;
58312 }
58313
58314
58315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
58316   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58317
58318   arg1 = (Dali::Timer *)jarg1;
58319   {
58320     try {
58321       delete arg1;
58322     } catch (std::out_of_range& e) {
58323       {
58324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58325       };
58326     } catch (std::exception& e) {
58327       {
58328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58329       };
58330     } catch (Dali::DaliException e) {
58331       {
58332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58333       };
58334     } catch (...) {
58335       {
58336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58337       };
58338     }
58339   }
58340
58341 }
58342
58343
58344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
58345   void * jresult ;
58346   Dali::BaseHandle arg1 ;
58347   Dali::BaseHandle *argp1 ;
58348   Dali::Timer result;
58349
58350   argp1 = (Dali::BaseHandle *)jarg1;
58351   if (!argp1) {
58352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58353     return 0;
58354   }
58355   arg1 = *argp1;
58356   {
58357     try {
58358       result = Dali::Timer::DownCast(arg1);
58359     } catch (std::out_of_range& e) {
58360       {
58361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58362       };
58363     } catch (std::exception& e) {
58364       {
58365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58366       };
58367     } catch (Dali::DaliException e) {
58368       {
58369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58370       };
58371     } catch (...) {
58372       {
58373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58374       };
58375     }
58376   }
58377
58378   jresult = new Dali::Timer((const Dali::Timer &)result);
58379   return jresult;
58380 }
58381
58382
58383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
58384   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58385
58386   arg1 = (Dali::Timer *)jarg1;
58387   {
58388     try {
58389       (arg1)->Start();
58390     } catch (std::out_of_range& e) {
58391       {
58392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58393       };
58394     } catch (std::exception& e) {
58395       {
58396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58397       };
58398     } catch (Dali::DaliException e) {
58399       {
58400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58401       };
58402     } catch (...) {
58403       {
58404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58405       };
58406     }
58407   }
58408
58409 }
58410
58411
58412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
58413   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58414
58415   arg1 = (Dali::Timer *)jarg1;
58416   {
58417     try {
58418       (arg1)->Stop();
58419     } catch (std::out_of_range& e) {
58420       {
58421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58422       };
58423     } catch (std::exception& e) {
58424       {
58425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58426       };
58427     } catch (Dali::DaliException e) {
58428       {
58429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58430       };
58431     } catch (...) {
58432       {
58433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58434       };
58435     }
58436   }
58437
58438 }
58439
58440
58441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
58442   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58443   unsigned int arg2 ;
58444
58445   arg1 = (Dali::Timer *)jarg1;
58446   arg2 = (unsigned int)jarg2;
58447   {
58448     try {
58449       (arg1)->SetInterval(arg2);
58450     } catch (std::out_of_range& e) {
58451       {
58452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58453       };
58454     } catch (std::exception& e) {
58455       {
58456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58457       };
58458     } catch (Dali::DaliException e) {
58459       {
58460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58461       };
58462     } catch (...) {
58463       {
58464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58465       };
58466     }
58467   }
58468
58469 }
58470
58471
58472 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
58473   unsigned int jresult ;
58474   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58475   unsigned int result;
58476
58477   arg1 = (Dali::Timer *)jarg1;
58478   {
58479     try {
58480       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
58481     } catch (std::out_of_range& e) {
58482       {
58483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58484       };
58485     } catch (std::exception& e) {
58486       {
58487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58488       };
58489     } catch (Dali::DaliException e) {
58490       {
58491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58492       };
58493     } catch (...) {
58494       {
58495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58496       };
58497     }
58498   }
58499
58500   jresult = result;
58501   return jresult;
58502 }
58503
58504
58505 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
58506   unsigned int jresult ;
58507   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58508   bool result;
58509
58510   arg1 = (Dali::Timer *)jarg1;
58511   {
58512     try {
58513       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
58514     } catch (std::out_of_range& e) {
58515       {
58516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58517       };
58518     } catch (std::exception& e) {
58519       {
58520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58521       };
58522     } catch (Dali::DaliException e) {
58523       {
58524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58525       };
58526     } catch (...) {
58527       {
58528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58529       };
58530     }
58531   }
58532
58533   jresult = result;
58534   return jresult;
58535 }
58536
58537
58538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
58539   void * jresult ;
58540   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58541   Dali::Timer::TimerSignalType *result = 0 ;
58542
58543   arg1 = (Dali::Timer *)jarg1;
58544   {
58545     try {
58546       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
58547     } catch (std::out_of_range& e) {
58548       {
58549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58550       };
58551     } catch (std::exception& e) {
58552       {
58553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58554       };
58555     } catch (Dali::DaliException e) {
58556       {
58557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58558       };
58559     } catch (...) {
58560       {
58561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58562       };
58563     }
58564   }
58565
58566   jresult = (void *)result;
58567   return jresult;
58568 }
58569
58570
58571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DragAndDropDetector() {
58572   void * jresult ;
58573   Dali::DragAndDropDetector *result = 0 ;
58574
58575   {
58576     try {
58577       result = (Dali::DragAndDropDetector *)new Dali::DragAndDropDetector();
58578     } catch (std::out_of_range& e) {
58579       {
58580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58581       };
58582     } catch (std::exception& e) {
58583       {
58584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58585       };
58586     } catch (Dali::DaliException e) {
58587       {
58588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58589       };
58590     } catch (...) {
58591       {
58592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58593       };
58594     }
58595   }
58596
58597   jresult = (void *)result;
58598   return jresult;
58599 }
58600
58601
58602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DragAndDropDetector(void * jarg1) {
58603   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58604
58605   arg1 = (Dali::DragAndDropDetector *)jarg1;
58606   {
58607     try {
58608       delete arg1;
58609     } catch (std::out_of_range& e) {
58610       {
58611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58612       };
58613     } catch (std::exception& e) {
58614       {
58615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58616       };
58617     } catch (Dali::DaliException e) {
58618       {
58619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58620       };
58621     } catch (...) {
58622       {
58623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58624       };
58625     }
58626   }
58627
58628 }
58629
58630
58631 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetContent(void * jarg1) {
58632   char * jresult ;
58633   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58634   std::string *result = 0 ;
58635
58636   arg1 = (Dali::DragAndDropDetector *)jarg1;
58637   {
58638     try {
58639       result = (std::string *) &((Dali::DragAndDropDetector const *)arg1)->GetContent();
58640     } catch (std::out_of_range& e) {
58641       {
58642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58643       };
58644     } catch (std::exception& e) {
58645       {
58646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58647       };
58648     } catch (Dali::DaliException e) {
58649       {
58650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58651       };
58652     } catch (...) {
58653       {
58654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58655       };
58656     }
58657   }
58658
58659   jresult = SWIG_csharp_string_callback(result->c_str());
58660   return jresult;
58661 }
58662
58663
58664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetCurrentScreenPosition(void * jarg1) {
58665   void * jresult ;
58666   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58667   Dali::Vector2 result;
58668
58669   arg1 = (Dali::DragAndDropDetector *)jarg1;
58670   {
58671     try {
58672       result = ((Dali::DragAndDropDetector const *)arg1)->GetCurrentScreenPosition();
58673     } catch (std::out_of_range& e) {
58674       {
58675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58676       };
58677     } catch (std::exception& e) {
58678       {
58679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58680       };
58681     } catch (Dali::DaliException e) {
58682       {
58683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58684       };
58685     } catch (...) {
58686       {
58687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58688       };
58689     }
58690   }
58691
58692   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
58693   return jresult;
58694 }
58695
58696
58697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_EnteredSignal(void * jarg1) {
58698   void * jresult ;
58699   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58700   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58701
58702   arg1 = (Dali::DragAndDropDetector *)jarg1;
58703   {
58704     try {
58705       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->EnteredSignal();
58706     } catch (std::out_of_range& e) {
58707       {
58708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58709       };
58710     } catch (std::exception& e) {
58711       {
58712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58713       };
58714     } catch (Dali::DaliException e) {
58715       {
58716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58717       };
58718     } catch (...) {
58719       {
58720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58721       };
58722     }
58723   }
58724
58725   jresult = (void *)result;
58726   return jresult;
58727 }
58728
58729
58730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_ExitedSignal(void * jarg1) {
58731   void * jresult ;
58732   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58733   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58734
58735   arg1 = (Dali::DragAndDropDetector *)jarg1;
58736   {
58737     try {
58738       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->ExitedSignal();
58739     } catch (std::out_of_range& e) {
58740       {
58741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58742       };
58743     } catch (std::exception& e) {
58744       {
58745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58746       };
58747     } catch (Dali::DaliException e) {
58748       {
58749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58750       };
58751     } catch (...) {
58752       {
58753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58754       };
58755     }
58756   }
58757
58758   jresult = (void *)result;
58759   return jresult;
58760 }
58761
58762
58763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_MovedSignal(void * jarg1) {
58764   void * jresult ;
58765   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58766   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58767
58768   arg1 = (Dali::DragAndDropDetector *)jarg1;
58769   {
58770     try {
58771       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->MovedSignal();
58772     } catch (std::out_of_range& e) {
58773       {
58774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58775       };
58776     } catch (std::exception& e) {
58777       {
58778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58779       };
58780     } catch (Dali::DaliException e) {
58781       {
58782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58783       };
58784     } catch (...) {
58785       {
58786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58787       };
58788     }
58789   }
58790
58791   jresult = (void *)result;
58792   return jresult;
58793 }
58794
58795
58796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_DroppedSignal(void * jarg1) {
58797   void * jresult ;
58798   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58799   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58800
58801   arg1 = (Dali::DragAndDropDetector *)jarg1;
58802   {
58803     try {
58804       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->DroppedSignal();
58805     } catch (std::out_of_range& e) {
58806       {
58807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58808       };
58809     } catch (std::exception& e) {
58810       {
58811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58812       };
58813     } catch (Dali::DaliException e) {
58814       {
58815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58816       };
58817     } catch (...) {
58818       {
58819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58820       };
58821     }
58822   }
58823
58824   jresult = (void *)result;
58825   return jresult;
58826 }
58827
58828
58829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_0() {
58830   void * jresult ;
58831   Dali::ApplicationExtensions *result = 0 ;
58832
58833   {
58834     try {
58835       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions();
58836     } catch (std::out_of_range& e) {
58837       {
58838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58839       };
58840     } catch (std::exception& e) {
58841       {
58842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58843       };
58844     } catch (Dali::DaliException e) {
58845       {
58846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58847       };
58848     } catch (...) {
58849       {
58850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58851       };
58852     }
58853   }
58854
58855   jresult = (void *)result;
58856   return jresult;
58857 }
58858
58859
58860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_1(void * jarg1) {
58861   void * jresult ;
58862   Dali::Application *arg1 = (Dali::Application *) 0 ;
58863   Dali::ApplicationExtensions *result = 0 ;
58864
58865   arg1 = (Dali::Application *)jarg1;
58866   {
58867     try {
58868       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions(arg1);
58869     } catch (std::out_of_range& e) {
58870       {
58871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58872       };
58873     } catch (std::exception& e) {
58874       {
58875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58876       };
58877     } catch (Dali::DaliException e) {
58878       {
58879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58880       };
58881     } catch (...) {
58882       {
58883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58884       };
58885     }
58886   }
58887
58888   jresult = (void *)result;
58889   return jresult;
58890 }
58891
58892
58893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationExtensions(void * jarg1) {
58894   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
58895
58896   arg1 = (Dali::ApplicationExtensions *)jarg1;
58897   {
58898     try {
58899       delete arg1;
58900     } catch (std::out_of_range& e) {
58901       {
58902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58903       };
58904     } catch (std::exception& e) {
58905       {
58906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58907       };
58908     } catch (Dali::DaliException e) {
58909       {
58910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58911       };
58912     } catch (...) {
58913       {
58914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58915       };
58916     }
58917   }
58918
58919 }
58920
58921
58922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Init(void * jarg1) {
58923   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
58924
58925   arg1 = (Dali::ApplicationExtensions *)jarg1;
58926   {
58927     try {
58928       (arg1)->Init();
58929     } catch (std::out_of_range& e) {
58930       {
58931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58932       };
58933     } catch (std::exception& e) {
58934       {
58935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58936       };
58937     } catch (Dali::DaliException e) {
58938       {
58939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58940       };
58941     } catch (...) {
58942       {
58943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58944       };
58945     }
58946   }
58947
58948 }
58949
58950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Start(void * jarg1) {
58951   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
58952
58953   arg1 = (Dali::ApplicationExtensions *)jarg1;
58954   {
58955     try {
58956       (arg1)->Start();
58957     } catch (std::out_of_range& e) {
58958       {
58959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58960       };
58961     } catch (std::exception& e) {
58962       {
58963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58964       };
58965     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }
58966   }
58967 }
58968
58969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Terminate(void * jarg1) {
58970   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
58971
58972   arg1 = (Dali::ApplicationExtensions *)jarg1;
58973   {
58974     try {
58975       (arg1)->Terminate();
58976     } catch (std::out_of_range& e) {
58977       {
58978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58979       };
58980     } catch (std::exception& e) {
58981       {
58982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58983       };
58984     } catch (Dali::DaliException e) {
58985       {
58986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58987       };
58988     } catch (...) {
58989       {
58990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58991       };
58992     }
58993   }
58994
58995 }
58996
58997
58998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Pause(void * jarg1) {
58999   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59000
59001   arg1 = (Dali::ApplicationExtensions *)jarg1;
59002   {
59003     try {
59004       (arg1)->Pause();
59005     } catch (std::out_of_range& e) {
59006       {
59007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59008       };
59009     } catch (std::exception& e) {
59010       {
59011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59012       };
59013     } catch (Dali::DaliException e) {
59014       {
59015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59016       };
59017     } catch (...) {
59018       {
59019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59020       };
59021     }
59022   }
59023
59024 }
59025
59026
59027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Resume(void * jarg1) {
59028   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59029
59030   arg1 = (Dali::ApplicationExtensions *)jarg1;
59031   {
59032     try {
59033       (arg1)->Resume();
59034     } catch (std::out_of_range& e) {
59035       {
59036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59037       };
59038     } catch (std::exception& e) {
59039       {
59040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59041       };
59042     } catch (Dali::DaliException e) {
59043       {
59044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59045       };
59046     } catch (...) {
59047       {
59048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59049       };
59050     }
59051   }
59052
59053 }
59054
59055
59056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_LanguageChange(void * jarg1) {
59057   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59058
59059   arg1 = (Dali::ApplicationExtensions *)jarg1;
59060   {
59061     try {
59062       (arg1)->LanguageChange();
59063     } catch (std::out_of_range& e) {
59064       {
59065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59066       };
59067     } catch (std::exception& e) {
59068       {
59069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59070       };
59071     } catch (Dali::DaliException e) {
59072       {
59073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59074       };
59075     } catch (...) {
59076       {
59077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59078       };
59079     }
59080   }
59081
59082 }
59083
59084
59085
59086 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
59087   unsigned int jresult ;
59088   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59089   bool result;
59090
59091   arg1 = (Dali::Signal< bool () > *)jarg1;
59092   {
59093     try {
59094       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
59095     } catch (std::out_of_range& e) {
59096       {
59097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59098       };
59099     } catch (std::exception& e) {
59100       {
59101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59102       };
59103     } catch (Dali::DaliException e) {
59104       {
59105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59106       };
59107     } catch (...) {
59108       {
59109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59110       };
59111     }
59112   }
59113
59114   jresult = result;
59115   return jresult;
59116 }
59117
59118
59119 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
59120   unsigned long jresult ;
59121   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59122   std::size_t result;
59123
59124   arg1 = (Dali::Signal< bool () > *)jarg1;
59125   {
59126     try {
59127       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
59128     } catch (std::out_of_range& e) {
59129       {
59130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59131       };
59132     } catch (std::exception& e) {
59133       {
59134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59135       };
59136     } catch (Dali::DaliException e) {
59137       {
59138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59139       };
59140     } catch (...) {
59141       {
59142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59143       };
59144     }
59145   }
59146
59147   jresult = (unsigned long)result;
59148   return jresult;
59149 }
59150
59151
59152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
59153   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59154   bool (*arg2)() = (bool (*)()) 0 ;
59155
59156   arg1 = (Dali::Signal< bool () > *)jarg1;
59157   arg2 = (bool (*)())jarg2;
59158   {
59159     try {
59160       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
59161     } catch (std::out_of_range& e) {
59162       {
59163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59164       };
59165     } catch (std::exception& e) {
59166       {
59167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59168       };
59169     } catch (Dali::DaliException e) {
59170       {
59171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59172       };
59173     } catch (...) {
59174       {
59175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59176       };
59177     }
59178   }
59179
59180 }
59181
59182
59183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
59184   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59185   bool (*arg2)() = (bool (*)()) 0 ;
59186
59187   arg1 = (Dali::Signal< bool () > *)jarg1;
59188   arg2 = (bool (*)())jarg2;
59189   {
59190     try {
59191       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
59192     } catch (std::out_of_range& e) {
59193       {
59194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59195       };
59196     } catch (std::exception& e) {
59197       {
59198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59199       };
59200     } catch (Dali::DaliException e) {
59201       {
59202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59203       };
59204     } catch (...) {
59205       {
59206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59207       };
59208     }
59209   }
59210
59211 }
59212
59213
59214 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
59215   unsigned int jresult ;
59216   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59217   bool result;
59218
59219   arg1 = (Dali::Signal< bool () > *)jarg1;
59220   {
59221     try {
59222       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
59223     } catch (std::out_of_range& e) {
59224       {
59225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59226       };
59227     } catch (std::exception& e) {
59228       {
59229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59230       };
59231     } catch (Dali::DaliException e) {
59232       {
59233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59234       };
59235     } catch (...) {
59236       {
59237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59238       };
59239     }
59240   }
59241
59242   jresult = result;
59243   return jresult;
59244 }
59245
59246
59247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
59248   void * jresult ;
59249   Dali::Signal< bool () > *result = 0 ;
59250
59251   {
59252     try {
59253       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
59254     } catch (std::out_of_range& e) {
59255       {
59256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59257       };
59258     } catch (std::exception& e) {
59259       {
59260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59261       };
59262     } catch (Dali::DaliException e) {
59263       {
59264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59265       };
59266     } catch (...) {
59267       {
59268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59269       };
59270     }
59271   }
59272
59273   jresult = (void *)result;
59274   return jresult;
59275 }
59276
59277
59278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
59279   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59280
59281   arg1 = (Dali::Signal< bool () > *)jarg1;
59282   {
59283     try {
59284       delete arg1;
59285     } catch (std::out_of_range& e) {
59286       {
59287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59288       };
59289     } catch (std::exception& e) {
59290       {
59291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59292       };
59293     } catch (Dali::DaliException e) {
59294       {
59295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59296       };
59297     } catch (...) {
59298       {
59299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59300       };
59301     }
59302   }
59303
59304 }
59305
59306
59307 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
59308   int jresult ;
59309   int result;
59310
59311   {
59312     try {
59313       result = (int)Dali::Toolkit::Visual::Property::TYPE;
59314     } catch (std::out_of_range& e) {
59315       {
59316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59317       };
59318     } catch (std::exception& e) {
59319       {
59320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59321       };
59322     } catch (Dali::DaliException e) {
59323       {
59324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59325       };
59326     } catch (...) {
59327       {
59328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59329       };
59330     }
59331   }
59332
59333   jresult = (int)result;
59334   return jresult;
59335 }
59336
59337
59338 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
59339   int jresult ;
59340   int result;
59341
59342   {
59343     try {
59344       result = (int)Dali::Toolkit::Visual::Property::SHADER;
59345     } catch (std::out_of_range& e) {
59346       {
59347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59348       };
59349     } catch (std::exception& e) {
59350       {
59351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59352       };
59353     } catch (Dali::DaliException e) {
59354       {
59355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59356       };
59357     } catch (...) {
59358       {
59359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59360       };
59361     }
59362   }
59363
59364   jresult = (int)result;
59365   return jresult;
59366 }
59367
59368
59369 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
59370   int jresult ;
59371   int result;
59372
59373   {
59374     try {
59375       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
59376     } catch (std::out_of_range& e) {
59377       {
59378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59379       };
59380     } catch (std::exception& e) {
59381       {
59382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59383       };
59384     } catch (Dali::DaliException e) {
59385       {
59386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59387       };
59388     } catch (...) {
59389       {
59390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59391       };
59392     }
59393   }
59394
59395   jresult = (int)result;
59396   return jresult;
59397 }
59398
59399
59400 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
59401   int jresult ;
59402   int result;
59403
59404   {
59405     try {
59406       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
59407     } catch (std::out_of_range& e) {
59408       {
59409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59410       };
59411     } catch (std::exception& e) {
59412       {
59413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59414       };
59415     } catch (Dali::DaliException e) {
59416       {
59417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59418       };
59419     } catch (...) {
59420       {
59421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59422       };
59423     }
59424   }
59425
59426   jresult = (int)result;
59427   return jresult;
59428 }
59429
59430
59431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
59432   int jresult ;
59433   int result;
59434
59435   {
59436     try {
59437       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
59438     } catch (std::out_of_range& e) {
59439       {
59440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59441       };
59442     } catch (std::exception& e) {
59443       {
59444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59445       };
59446     } catch (Dali::DaliException e) {
59447       {
59448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59449       };
59450     } catch (...) {
59451       {
59452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59453       };
59454     }
59455   }
59456
59457   jresult = (int)result;
59458   return jresult;
59459 }
59460
59461
59462 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
59463   int jresult ;
59464   int result;
59465
59466   {
59467     try {
59468       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
59469     } catch (std::out_of_range& e) {
59470       {
59471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59472       };
59473     } catch (std::exception& e) {
59474       {
59475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59476       };
59477     } catch (Dali::DaliException e) {
59478       {
59479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59480       };
59481     } catch (...) {
59482       {
59483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59484       };
59485     }
59486   }
59487
59488   jresult = (int)result;
59489   return jresult;
59490 }
59491
59492
59493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
59494   int jresult ;
59495   int result;
59496
59497   {
59498     try {
59499       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
59500     } catch (std::out_of_range& e) {
59501       {
59502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59503       };
59504     } catch (std::exception& e) {
59505       {
59506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59507       };
59508     } catch (Dali::DaliException e) {
59509       {
59510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59511       };
59512     } catch (...) {
59513       {
59514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59515       };
59516     }
59517   }
59518
59519   jresult = (int)result;
59520   return jresult;
59521 }
59522
59523
59524 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
59525   int jresult ;
59526   int result;
59527
59528   {
59529     try {
59530       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
59531     } catch (std::out_of_range& e) {
59532       {
59533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59534       };
59535     } catch (std::exception& e) {
59536       {
59537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59538       };
59539     } catch (Dali::DaliException e) {
59540       {
59541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59542       };
59543     } catch (...) {
59544       {
59545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59546       };
59547     }
59548   }
59549
59550   jresult = (int)result;
59551   return jresult;
59552 }
59553
59554
59555 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
59556   int jresult ;
59557   int result;
59558
59559   {
59560     try {
59561       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
59562     } catch (std::out_of_range& e) {
59563       {
59564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59565       };
59566     } catch (std::exception& e) {
59567       {
59568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59569       };
59570     } catch (Dali::DaliException e) {
59571       {
59572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59573       };
59574     } catch (...) {
59575       {
59576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59577       };
59578     }
59579   }
59580
59581   jresult = (int)result;
59582   return jresult;
59583 }
59584
59585
59586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
59587   int jresult ;
59588   int result;
59589
59590   {
59591     try {
59592       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
59593     } catch (std::out_of_range& e) {
59594       {
59595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59596       };
59597     } catch (std::exception& e) {
59598       {
59599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59600       };
59601     } catch (Dali::DaliException e) {
59602       {
59603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59604       };
59605     } catch (...) {
59606       {
59607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59608       };
59609     }
59610   }
59611
59612   jresult = (int)result;
59613   return jresult;
59614 }
59615
59616
59617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
59618   int jresult ;
59619   int result;
59620
59621   {
59622     try {
59623       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
59624     } catch (std::out_of_range& e) {
59625       {
59626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59627       };
59628     } catch (std::exception& e) {
59629       {
59630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59631       };
59632     } catch (Dali::DaliException e) {
59633       {
59634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59635       };
59636     } catch (...) {
59637       {
59638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59639       };
59640     }
59641   }
59642
59643   jresult = (int)result;
59644   return jresult;
59645 }
59646
59647
59648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
59649   int jresult ;
59650   int result;
59651
59652   {
59653     try {
59654       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
59655     } catch (std::out_of_range& e) {
59656       {
59657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59658       };
59659     } catch (std::exception& e) {
59660       {
59661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59662       };
59663     } catch (Dali::DaliException e) {
59664       {
59665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59666       };
59667     } catch (...) {
59668       {
59669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59670       };
59671     }
59672   }
59673
59674   jresult = (int)result;
59675   return jresult;
59676 }
59677
59678
59679 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
59680   int jresult ;
59681   int result;
59682
59683   {
59684     try {
59685       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
59686     } catch (std::out_of_range& e) {
59687       {
59688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59689       };
59690     } catch (std::exception& e) {
59691       {
59692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59693       };
59694     } catch (Dali::DaliException e) {
59695       {
59696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59697       };
59698     } catch (...) {
59699       {
59700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59701       };
59702     }
59703   }
59704
59705   jresult = (int)result;
59706   return jresult;
59707 }
59708
59709
59710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
59711   int jresult ;
59712   int result;
59713
59714   {
59715     try {
59716       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
59717     } catch (std::out_of_range& e) {
59718       {
59719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59720       };
59721     } catch (std::exception& e) {
59722       {
59723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59724       };
59725     } catch (Dali::DaliException e) {
59726       {
59727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59728       };
59729     } catch (...) {
59730       {
59731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59732       };
59733     }
59734   }
59735
59736   jresult = (int)result;
59737   return jresult;
59738 }
59739
59740
59741 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
59742   int jresult ;
59743   int result;
59744
59745   {
59746     try {
59747       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
59748     } catch (std::out_of_range& e) {
59749       {
59750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59751       };
59752     } catch (std::exception& e) {
59753       {
59754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59755       };
59756     } catch (Dali::DaliException e) {
59757       {
59758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59759       };
59760     } catch (...) {
59761       {
59762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59763       };
59764     }
59765   }
59766
59767   jresult = (int)result;
59768   return jresult;
59769 }
59770
59771
59772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
59773   int jresult ;
59774   int result;
59775
59776   {
59777     try {
59778       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
59779     } catch (std::out_of_range& e) {
59780       {
59781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59782       };
59783     } catch (std::exception& e) {
59784       {
59785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59786       };
59787     } catch (Dali::DaliException e) {
59788       {
59789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59790       };
59791     } catch (...) {
59792       {
59793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59794       };
59795     }
59796   }
59797
59798   jresult = (int)result;
59799   return jresult;
59800 }
59801
59802
59803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
59804   int jresult ;
59805   int result;
59806
59807   {
59808     try {
59809       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
59810     } catch (std::out_of_range& e) {
59811       {
59812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59813       };
59814     } catch (std::exception& e) {
59815       {
59816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59817       };
59818     } catch (Dali::DaliException e) {
59819       {
59820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59821       };
59822     } catch (...) {
59823       {
59824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59825       };
59826     }
59827   }
59828
59829   jresult = (int)result;
59830   return jresult;
59831 }
59832
59833
59834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
59835   int jresult ;
59836   int result;
59837
59838   {
59839     try {
59840       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
59841     } catch (std::out_of_range& e) {
59842       {
59843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59844       };
59845     } catch (std::exception& e) {
59846       {
59847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59848       };
59849     } catch (Dali::DaliException e) {
59850       {
59851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59852       };
59853     } catch (...) {
59854       {
59855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59856       };
59857     }
59858   }
59859
59860   jresult = (int)result;
59861   return jresult;
59862 }
59863
59864
59865 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
59866   int jresult ;
59867   int result;
59868
59869   {
59870     try {
59871       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
59872     } catch (std::out_of_range& e) {
59873       {
59874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59875       };
59876     } catch (std::exception& e) {
59877       {
59878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59879       };
59880     } catch (Dali::DaliException e) {
59881       {
59882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59883       };
59884     } catch (...) {
59885       {
59886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59887       };
59888     }
59889   }
59890
59891   jresult = (int)result;
59892   return jresult;
59893 }
59894
59895
59896 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
59897   int jresult ;
59898   int result;
59899
59900   {
59901     try {
59902       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
59903     } catch (std::out_of_range& e) {
59904       {
59905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59906       };
59907     } catch (std::exception& e) {
59908       {
59909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59910       };
59911     } catch (Dali::DaliException e) {
59912       {
59913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59914       };
59915     } catch (...) {
59916       {
59917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59918       };
59919     }
59920   }
59921
59922   jresult = (int)result;
59923   return jresult;
59924 }
59925
59926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
59927   int jresult ;
59928   int result;
59929
59930   {
59931     try {
59932       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
59933     } catch (std::out_of_range& e) {
59934       {
59935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59936       };
59937     } catch (std::exception& e) {
59938       {
59939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59940       };
59941     } catch (Dali::DaliException e) {
59942       {
59943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59944       };
59945     } catch (...) {
59946       {
59947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59948       };
59949     }
59950   }
59951
59952   jresult = (int)result;
59953   return jresult;
59954 }
59955
59956
59957 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
59958   int jresult ;
59959   int result;
59960   {
59961     try
59962     {
59963       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
59964     } catch (std::out_of_range& e) {
59965       {
59966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59967       };
59968     } catch (std::exception& e) {
59969       {
59970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59971       };
59972     } catch (Dali::DaliException e) {
59973       {
59974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59975       };
59976     } catch (...) {
59977       {
59978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59979       };
59980     }
59981   }
59982
59983   jresult = (int)result;
59984   return jresult;
59985 }
59986
59987 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
59988   int jresult ;
59989   int result;
59990   {
59991     try
59992     {
59993       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
59994     } catch (std::out_of_range& e) {
59995       {
59996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59997       };
59998     } catch (std::exception& e) {
59999       {
60000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60001       };
60002     } catch (Dali::DaliException e) {
60003       {
60004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60005       };
60006     } catch (...) {
60007       {
60008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60009       };
60010     }
60011   }
60012
60013   jresult = (int)result;
60014   return jresult;
60015 }
60016
60017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
60018   int jresult ;
60019   int result;
60020   {
60021     try
60022     {
60023       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
60024     } catch (std::out_of_range& e) {
60025       {
60026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60027       };
60028     } catch (std::exception& e) {
60029       {
60030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60031       };
60032     } catch (Dali::DaliException e) {
60033       {
60034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60035       };
60036     } catch (...) {
60037       {
60038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60039       };
60040     }
60041   }
60042
60043   jresult = (int)result;
60044   return jresult;
60045 }
60046
60047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
60048   int jresult ;
60049   int result;
60050   {
60051     try
60052     {
60053       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
60054     } catch (std::out_of_range& e) {
60055       {
60056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60057       };
60058     } catch (std::exception& e) {
60059       {
60060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60061       };
60062     } catch (Dali::DaliException e) {
60063       {
60064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60065       };
60066     } catch (...) {
60067       {
60068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60069       };
60070     }
60071   }
60072
60073   jresult = (int)result;
60074   return jresult;
60075 }
60076
60077 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
60078   int jresult ;
60079   int result;
60080   {
60081     try
60082     {
60083       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
60084     } catch (std::out_of_range& e) {
60085       {
60086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60087       };
60088     } catch (std::exception& e) {
60089       {
60090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60091       };
60092     } catch (Dali::DaliException e) {
60093       {
60094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60095       };
60096     } catch (...) {
60097       {
60098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60099       };
60100     }
60101   }
60102
60103   jresult = (int)result;
60104   return jresult;
60105 }
60106
60107 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
60108   int jresult ;
60109   int result;
60110
60111   {
60112     try {
60113       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
60114     } catch (std::out_of_range& e) {
60115       {
60116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60117       };
60118     } catch (std::exception& e) {
60119       {
60120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60121       };
60122     } catch (Dali::DaliException e) {
60123       {
60124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60125       };
60126     } catch (...) {
60127       {
60128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60129       };
60130     }
60131   }
60132
60133   jresult = (int)result;
60134   return jresult;
60135 }
60136
60137
60138 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
60139   int jresult ;
60140   int result;
60141
60142   {
60143     try {
60144       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
60145     } catch (std::out_of_range& e) {
60146       {
60147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60148       };
60149     } catch (std::exception& e) {
60150       {
60151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60152       };
60153     } catch (Dali::DaliException e) {
60154       {
60155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60156       };
60157     } catch (...) {
60158       {
60159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60160       };
60161     }
60162   }
60163
60164   jresult = (int)result;
60165   return jresult;
60166 }
60167
60168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
60169   int jresult ;
60170   int result;
60171   {
60172     try
60173     {
60174       result = (int)Dali::Toolkit::DevelImageVisual::Property::RELEASE_POLICY;
60175     } catch (std::out_of_range& e) {
60176       {
60177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60178       };
60179     } catch (std::exception& e) {
60180       {
60181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60182       };
60183     } catch (...) {
60184       {
60185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60186       };
60187     }
60188   }
60189   jresult = (int)result;
60190   return jresult;
60191 }
60192
60193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
60194   int jresult ;
60195   int result;
60196   {
60197     try
60198     {
60199       result = (int)Dali::Toolkit::DevelImageVisual::Property::LOAD_POLICY;
60200     } catch (std::out_of_range& e) {
60201       {
60202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60203       };
60204     } catch (std::exception& e) {
60205       {
60206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60207       };
60208     } catch (...) {
60209       {
60210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60211       };
60212     }
60213   }
60214   jresult = (int)result;
60215   return jresult;
60216 }
60217
60218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
60219   int jresult ;
60220   int result;
60221   {
60222     try
60223     {
60224       result = (int)Dali::Toolkit::DevelImageVisual::Property::ORIENTATION_CORRECTION;
60225     } catch (std::out_of_range& e) {
60226       {
60227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60228       };
60229     } catch (std::exception& e) {
60230       {
60231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60232       };
60233     } catch (...) {
60234       {
60235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60236       };
60237     }
60238   }
60239   jresult = (int)result;
60240   return jresult;
60241 }
60242
60243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
60244   int jresult ;
60245   int result;
60246
60247   {
60248     try {
60249       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
60250     } catch (std::out_of_range& e) {
60251       {
60252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60253       };
60254     } catch (std::exception& e) {
60255       {
60256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60257       };
60258     } catch (Dali::DaliException e) {
60259       {
60260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60261       };
60262     } catch (...) {
60263       {
60264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60265       };
60266     }
60267   }
60268
60269   jresult = (int)result;
60270   return jresult;
60271 }
60272
60273
60274 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
60275   int jresult ;
60276   int result;
60277
60278   {
60279     try {
60280       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
60281     } catch (std::out_of_range& e) {
60282       {
60283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60284       };
60285     } catch (std::exception& e) {
60286       {
60287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60288       };
60289     } catch (Dali::DaliException e) {
60290       {
60291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60292       };
60293     } catch (...) {
60294       {
60295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60296       };
60297     }
60298   }
60299
60300   jresult = (int)result;
60301   return jresult;
60302 }
60303
60304
60305 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
60306   int jresult ;
60307   int result;
60308
60309   {
60310     try {
60311       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
60312     } catch (std::out_of_range& e) {
60313       {
60314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60315       };
60316     } catch (std::exception& e) {
60317       {
60318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60319       };
60320     } catch (Dali::DaliException e) {
60321       {
60322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60323       };
60324     } catch (...) {
60325       {
60326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60327       };
60328     }
60329   }
60330
60331   jresult = (int)result;
60332   return jresult;
60333 }
60334
60335
60336 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
60337   int jresult ;
60338   int result;
60339
60340   {
60341     try {
60342       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
60343     } catch (std::out_of_range& e) {
60344       {
60345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60346       };
60347     } catch (std::exception& e) {
60348       {
60349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60350       };
60351     } catch (Dali::DaliException e) {
60352       {
60353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60354       };
60355     } catch (...) {
60356       {
60357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60358       };
60359     }
60360   }
60361
60362   jresult = (int)result;
60363   return jresult;
60364 }
60365
60366
60367 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
60368   int jresult ;
60369   int result;
60370
60371   {
60372     try {
60373       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
60374     } catch (std::out_of_range& e) {
60375       {
60376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60377       };
60378     } catch (std::exception& e) {
60379       {
60380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60381       };
60382     } catch (Dali::DaliException e) {
60383       {
60384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60385       };
60386     } catch (...) {
60387       {
60388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60389       };
60390     }
60391   }
60392
60393   jresult = (int)result;
60394   return jresult;
60395 }
60396
60397
60398 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
60399   int jresult ;
60400   int result;
60401
60402   {
60403     try {
60404       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
60405     } catch (std::out_of_range& e) {
60406       {
60407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60408       };
60409     } catch (std::exception& e) {
60410       {
60411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60412       };
60413     } catch (Dali::DaliException e) {
60414       {
60415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60416       };
60417     } catch (...) {
60418       {
60419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60420       };
60421     }
60422   }
60423
60424   jresult = (int)result;
60425   return jresult;
60426 }
60427
60428
60429 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
60430   int jresult ;
60431   int result;
60432
60433   {
60434     try {
60435       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
60436     } catch (std::out_of_range& e) {
60437       {
60438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60439       };
60440     } catch (std::exception& e) {
60441       {
60442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60443       };
60444     } catch (Dali::DaliException e) {
60445       {
60446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60447       };
60448     } catch (...) {
60449       {
60450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60451       };
60452     }
60453   }
60454
60455   jresult = (int)result;
60456   return jresult;
60457 }
60458
60459 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
60460   int jresult ;
60461   int result;
60462
60463   {
60464     try {
60465       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
60466     } catch (std::out_of_range& e) {
60467       {
60468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60469       };
60470     } catch (std::exception& e) {
60471       {
60472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60473       };
60474     } catch (...) {
60475       {
60476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60477       };
60478     }
60479   }
60480   jresult = (int)result;
60481   return jresult;
60482 }
60483
60484 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
60485   int jresult ;
60486   int result;
60487
60488   {
60489     try {
60490       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
60491     } catch (std::out_of_range& e) {
60492       {
60493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60494       };
60495     } catch (std::exception& e) {
60496       {
60497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60498       };
60499     } catch (Dali::DaliException e) {
60500       {
60501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60502       };
60503     } catch (...) {
60504       {
60505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60506       };
60507     }
60508   }
60509
60510   jresult = (int)result;
60511   return jresult;
60512 }
60513
60514
60515 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
60516   int jresult ;
60517   int result;
60518
60519   {
60520     try {
60521       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
60522     } catch (std::out_of_range& e) {
60523       {
60524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60525       };
60526     } catch (std::exception& e) {
60527       {
60528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60529       };
60530     } catch (Dali::DaliException e) {
60531       {
60532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60533       };
60534     } catch (...) {
60535       {
60536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60537       };
60538     }
60539   }
60540
60541   jresult = (int)result;
60542   return jresult;
60543 }
60544
60545
60546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
60547   int jresult ;
60548   int result;
60549
60550   {
60551     try {
60552       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
60553     } catch (std::out_of_range& e) {
60554       {
60555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60556       };
60557     } catch (std::exception& e) {
60558       {
60559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60560       };
60561     } catch (Dali::DaliException e) {
60562       {
60563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60564       };
60565     } catch (...) {
60566       {
60567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60568       };
60569     }
60570   }
60571
60572   jresult = (int)result;
60573   return jresult;
60574 }
60575
60576
60577 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
60578   int jresult ;
60579   int result;
60580
60581   {
60582     try {
60583       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
60584     } catch (std::out_of_range& e) {
60585       {
60586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60587       };
60588     } catch (std::exception& e) {
60589       {
60590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60591       };
60592     } catch (Dali::DaliException e) {
60593       {
60594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60595       };
60596     } catch (...) {
60597       {
60598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60599       };
60600     }
60601   }
60602
60603   jresult = (int)result;
60604   return jresult;
60605 }
60606
60607
60608 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
60609   int jresult ;
60610   int result;
60611
60612   {
60613     try {
60614       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
60615     } catch (std::out_of_range& e) {
60616       {
60617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60618       };
60619     } catch (std::exception& e) {
60620       {
60621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60622       };
60623     } catch (Dali::DaliException e) {
60624       {
60625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60626       };
60627     } catch (...) {
60628       {
60629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60630       };
60631     }
60632   }
60633
60634   jresult = (int)result;
60635   return jresult;
60636 }
60637
60638
60639 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
60640   int jresult ;
60641   int result;
60642
60643   {
60644     try {
60645       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
60646     } catch (std::out_of_range& e) {
60647       {
60648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60649       };
60650     } catch (std::exception& e) {
60651       {
60652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60653       };
60654     } catch (Dali::DaliException e) {
60655       {
60656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60657       };
60658     } catch (...) {
60659       {
60660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60661       };
60662     }
60663   }
60664
60665   jresult = (int)result;
60666   return jresult;
60667 }
60668
60669
60670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
60671   int jresult ;
60672   int result;
60673
60674   {
60675     try {
60676       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
60677     } catch (std::out_of_range& e) {
60678       {
60679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60680       };
60681     } catch (std::exception& e) {
60682       {
60683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60684       };
60685     } catch (Dali::DaliException e) {
60686       {
60687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60688       };
60689     } catch (...) {
60690       {
60691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60692       };
60693     }
60694   }
60695
60696   jresult = (int)result;
60697   return jresult;
60698 }
60699
60700
60701 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
60702   int jresult ;
60703   int result;
60704
60705   {
60706     try {
60707       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
60708     } catch (std::out_of_range& e) {
60709       {
60710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60711       };
60712     } catch (std::exception& e) {
60713       {
60714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60715       };
60716     } catch (Dali::DaliException e) {
60717       {
60718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60719       };
60720     } catch (...) {
60721       {
60722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60723       };
60724     }
60725   }
60726
60727   jresult = (int)result;
60728   return jresult;
60729 }
60730
60731
60732 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
60733   int jresult ;
60734   int result;
60735
60736   {
60737     try {
60738       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
60739     } catch (std::out_of_range& e) {
60740       {
60741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60742       };
60743     } catch (std::exception& e) {
60744       {
60745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60746       };
60747     } catch (Dali::DaliException e) {
60748       {
60749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60750       };
60751     } catch (...) {
60752       {
60753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60754       };
60755     }
60756   }
60757
60758   jresult = (int)result;
60759   return jresult;
60760 }
60761
60762
60763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
60764   int jresult ;
60765   int result;
60766
60767   {
60768     try {
60769       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
60770     } catch (std::out_of_range& e) {
60771       {
60772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60773       };
60774     } catch (std::exception& e) {
60775       {
60776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60777       };
60778     } catch (Dali::DaliException e) {
60779       {
60780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60781       };
60782     } catch (...) {
60783       {
60784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60785       };
60786     }
60787   }
60788
60789   jresult = (int)result;
60790   return jresult;
60791 }
60792
60793
60794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
60795   int jresult ;
60796   int result;
60797
60798   {
60799     try {
60800       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
60801     } catch (std::out_of_range& e) {
60802       {
60803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60804       };
60805     } catch (std::exception& e) {
60806       {
60807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60808       };
60809     } catch (Dali::DaliException e) {
60810       {
60811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60812       };
60813     } catch (...) {
60814       {
60815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60816       };
60817     }
60818   }
60819
60820   jresult = (int)result;
60821   return jresult;
60822 }
60823
60824
60825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
60826   int jresult ;
60827   int result;
60828
60829   {
60830     try {
60831       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
60832     } catch (std::out_of_range& e) {
60833       {
60834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60835       };
60836     } catch (std::exception& e) {
60837       {
60838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60839       };
60840     } catch (Dali::DaliException e) {
60841       {
60842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60843       };
60844     } catch (...) {
60845       {
60846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60847       };
60848     }
60849   }
60850
60851   jresult = (int)result;
60852   return jresult;
60853 }
60854
60855
60856 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
60857   int jresult ;
60858   int result;
60859
60860   {
60861     try {
60862       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
60863     } catch (std::out_of_range& e) {
60864       {
60865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60866       };
60867     } catch (std::exception& e) {
60868       {
60869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60870       };
60871     } catch (Dali::DaliException e) {
60872       {
60873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60874       };
60875     } catch (...) {
60876       {
60877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60878       };
60879     }
60880   }
60881
60882   jresult = (int)result;
60883   return jresult;
60884 }
60885
60886
60887 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
60888   int jresult ;
60889   int result;
60890
60891   {
60892     try {
60893       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
60894     } catch (std::out_of_range& e) {
60895       {
60896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60897       };
60898     } catch (std::exception& e) {
60899       {
60900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60901       };
60902     } catch (Dali::DaliException e) {
60903       {
60904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60905       };
60906     } catch (...) {
60907       {
60908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60909       };
60910     }
60911   }
60912
60913   jresult = (int)result;
60914   return jresult;
60915 }
60916
60917
60918 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
60919   int jresult ;
60920   int result;
60921
60922   {
60923     try {
60924       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
60925     } catch (std::out_of_range& e) {
60926       {
60927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60928       };
60929     } catch (std::exception& e) {
60930       {
60931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60932       };
60933     } catch (Dali::DaliException e) {
60934       {
60935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60936       };
60937     } catch (...) {
60938       {
60939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60940       };
60941     }
60942   }
60943
60944   jresult = (int)result;
60945   return jresult;
60946 }
60947
60948
60949 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
60950   int jresult ;
60951   int result;
60952
60953   {
60954     try {
60955       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
60956     } catch (std::out_of_range& e) {
60957       {
60958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60959       };
60960     } catch (std::exception& e) {
60961       {
60962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60963       };
60964     } catch (Dali::DaliException e) {
60965       {
60966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60967       };
60968     } catch (...) {
60969       {
60970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60971       };
60972     }
60973   }
60974
60975   jresult = (int)result;
60976   return jresult;
60977 }
60978
60979
60980 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
60981   int jresult ;
60982   int result;
60983
60984   {
60985     try {
60986       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
60987     } catch (std::out_of_range& e) {
60988       {
60989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60990       };
60991     } catch (std::exception& e) {
60992       {
60993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60994       };
60995     } catch (Dali::DaliException e) {
60996       {
60997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60998       };
60999     } catch (...) {
61000       {
61001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61002       };
61003     }
61004   }
61005
61006   jresult = (int)result;
61007   return jresult;
61008 }
61009
61010
61011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
61012   int jresult ;
61013   int result;
61014
61015   {
61016     try {
61017       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
61018     } catch (std::out_of_range& e) {
61019       {
61020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61021       };
61022     } catch (std::exception& e) {
61023       {
61024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61025       };
61026     } catch (Dali::DaliException e) {
61027       {
61028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61029       };
61030     } catch (...) {
61031       {
61032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61033       };
61034     }
61035   }
61036
61037   jresult = (int)result;
61038   return jresult;
61039 }
61040
61041
61042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
61043   int jresult ;
61044   int result;
61045
61046   {
61047     try {
61048       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
61049     } catch (std::out_of_range& e) {
61050       {
61051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61052       };
61053     } catch (std::exception& e) {
61054       {
61055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61056       };
61057     } catch (Dali::DaliException e) {
61058       {
61059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61060       };
61061     } catch (...) {
61062       {
61063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61064       };
61065     }
61066   }
61067
61068   jresult = (int)result;
61069   return jresult;
61070 }
61071
61072
61073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
61074   int jresult ;
61075   int result;
61076
61077   {
61078     try {
61079       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
61080     } catch (std::out_of_range& e) {
61081       {
61082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61083       };
61084     } catch (std::exception& e) {
61085       {
61086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61087       };
61088     } catch (Dali::DaliException e) {
61089       {
61090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61091       };
61092     } catch (...) {
61093       {
61094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61095       };
61096     }
61097   }
61098
61099   jresult = (int)result;
61100   return jresult;
61101 }
61102
61103
61104 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
61105   int jresult ;
61106   int result;
61107
61108   {
61109     try {
61110       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
61111     } catch (std::out_of_range& e) {
61112       {
61113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61114       };
61115     } catch (std::exception& e) {
61116       {
61117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61118       };
61119     } catch (Dali::DaliException e) {
61120       {
61121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61122       };
61123     } catch (...) {
61124       {
61125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61126       };
61127     }
61128   }
61129
61130   jresult = (int)result;
61131   return jresult;
61132 }
61133
61134
61135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
61136   int jresult ;
61137   int result;
61138
61139   {
61140     try {
61141       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
61142     } catch (std::out_of_range& e) {
61143       {
61144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61145       };
61146     } catch (std::exception& e) {
61147       {
61148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61149       };
61150     } catch (Dali::DaliException e) {
61151       {
61152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61153       };
61154     } catch (...) {
61155       {
61156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61157       };
61158     }
61159   }
61160
61161   jresult = (int)result;
61162   return jresult;
61163 }
61164
61165
61166 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
61167   int jresult ;
61168   int result;
61169
61170   {
61171     try {
61172       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
61173     } catch (std::out_of_range& e) {
61174       {
61175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61176       };
61177     } catch (std::exception& e) {
61178       {
61179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61180       };
61181     } catch (Dali::DaliException e) {
61182       {
61183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61184       };
61185     } catch (...) {
61186       {
61187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61188       };
61189     }
61190   }
61191
61192   jresult = (int)result;
61193   return jresult;
61194 }
61195
61196
61197 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
61198   int jresult ;
61199   int result;
61200
61201   {
61202     try {
61203       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
61204     } catch (std::out_of_range& e) {
61205       {
61206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61207       };
61208     } catch (std::exception& e) {
61209       {
61210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61211       };
61212     } catch (Dali::DaliException e) {
61213       {
61214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61215       };
61216     } catch (...) {
61217       {
61218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61219       };
61220     }
61221   }
61222
61223   jresult = (int)result;
61224   return jresult;
61225 }
61226
61227
61228 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
61229   int jresult ;
61230   int result;
61231
61232   {
61233     try {
61234       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
61235     } catch (std::out_of_range& e) {
61236       {
61237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61238       };
61239     } catch (std::exception& e) {
61240       {
61241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61242       };
61243     } catch (Dali::DaliException e) {
61244       {
61245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61246       };
61247     } catch (...) {
61248       {
61249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61250       };
61251     }
61252   }
61253
61254   jresult = (int)result;
61255   return jresult;
61256 }
61257
61258
61259 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
61260   int jresult ;
61261   int result;
61262
61263   {
61264     try {
61265       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
61266     } catch (std::out_of_range& e) {
61267       {
61268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61269       };
61270     } catch (std::exception& e) {
61271       {
61272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61273       };
61274     } catch (Dali::DaliException e) {
61275       {
61276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61277       };
61278     } catch (...) {
61279       {
61280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61281       };
61282     }
61283   }
61284
61285   jresult = (int)result;
61286   return jresult;
61287 }
61288
61289
61290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
61291   int jresult ;
61292   int result;
61293
61294   {
61295     try {
61296       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
61297     } catch (std::out_of_range& e) {
61298       {
61299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61300       };
61301     } catch (std::exception& e) {
61302       {
61303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61304       };
61305     } catch (Dali::DaliException e) {
61306       {
61307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61308       };
61309     } catch (...) {
61310       {
61311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61312       };
61313     }
61314   }
61315
61316   jresult = (int)result;
61317   return jresult;
61318 }
61319
61320
61321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
61322   int jresult ;
61323   int result;
61324
61325   {
61326     try {
61327       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
61328     } catch (std::out_of_range& e) {
61329       {
61330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61331       };
61332     } catch (std::exception& e) {
61333       {
61334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61335       };
61336     } catch (Dali::DaliException e) {
61337       {
61338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61339       };
61340     } catch (...) {
61341       {
61342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61343       };
61344     }
61345   }
61346
61347   jresult = (int)result;
61348   return jresult;
61349 }
61350
61351
61352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
61353   void * jresult ;
61354   Dali::Toolkit::Builder *result = 0 ;
61355
61356   {
61357     try {
61358       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
61359     } catch (std::out_of_range& e) {
61360       {
61361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61362       };
61363     } catch (std::exception& e) {
61364       {
61365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61366       };
61367     } catch (Dali::DaliException e) {
61368       {
61369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61370       };
61371     } catch (...) {
61372       {
61373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61374       };
61375     }
61376   }
61377
61378   jresult = (void *)result;
61379   return jresult;
61380 }
61381
61382
61383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
61384   void * jresult ;
61385   Dali::Toolkit::Builder result;
61386
61387   {
61388     try {
61389       result = Dali::Toolkit::Builder::New();
61390     } catch (std::out_of_range& e) {
61391       {
61392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61393       };
61394     } catch (std::exception& e) {
61395       {
61396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61397       };
61398     } catch (Dali::DaliException e) {
61399       {
61400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61401       };
61402     } catch (...) {
61403       {
61404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61405       };
61406     }
61407   }
61408
61409   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
61410   return jresult;
61411 }
61412
61413
61414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
61415   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61416
61417   arg1 = (Dali::Toolkit::Builder *)jarg1;
61418   {
61419     try {
61420       delete arg1;
61421     } catch (std::out_of_range& e) {
61422       {
61423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61424       };
61425     } catch (std::exception& e) {
61426       {
61427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61428       };
61429     } catch (Dali::DaliException e) {
61430       {
61431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61432       };
61433     } catch (...) {
61434       {
61435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61436       };
61437     }
61438   }
61439
61440 }
61441
61442
61443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
61444   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61445   std::string *arg2 = 0 ;
61446   Dali::Toolkit::Builder::UIFormat arg3 ;
61447
61448   arg1 = (Dali::Toolkit::Builder *)jarg1;
61449   if (!jarg2) {
61450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61451     return ;
61452   }
61453   std::string arg2_str(jarg2);
61454   arg2 = &arg2_str;
61455   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
61456   {
61457     try {
61458       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
61459     } catch (std::out_of_range& e) {
61460       {
61461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61462       };
61463     } catch (std::exception& e) {
61464       {
61465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61466       };
61467     } catch (Dali::DaliException e) {
61468       {
61469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61470       };
61471     } catch (...) {
61472       {
61473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61474       };
61475     }
61476   }
61477
61478
61479   //argout typemap for const std::string&
61480
61481 }
61482
61483
61484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
61485   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61486   std::string *arg2 = 0 ;
61487
61488   arg1 = (Dali::Toolkit::Builder *)jarg1;
61489   if (!jarg2) {
61490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61491     return ;
61492   }
61493   std::string arg2_str(jarg2);
61494   arg2 = &arg2_str;
61495   {
61496     try {
61497       (arg1)->LoadFromString((std::string const &)*arg2);
61498     } catch (std::out_of_range& e) {
61499       {
61500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61501       };
61502     } catch (std::exception& e) {
61503       {
61504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61505       };
61506     } catch (Dali::DaliException e) {
61507       {
61508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61509       };
61510     } catch (...) {
61511       {
61512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61513       };
61514     }
61515   }
61516
61517
61518   //argout typemap for const std::string&
61519
61520 }
61521
61522
61523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
61524   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61525   Dali::Property::Map *arg2 = 0 ;
61526
61527   arg1 = (Dali::Toolkit::Builder *)jarg1;
61528   arg2 = (Dali::Property::Map *)jarg2;
61529   if (!arg2) {
61530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61531     return ;
61532   }
61533   {
61534     try {
61535       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
61536     } catch (std::out_of_range& e) {
61537       {
61538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61539       };
61540     } catch (std::exception& e) {
61541       {
61542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61543       };
61544     } catch (Dali::DaliException e) {
61545       {
61546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61547       };
61548     } catch (...) {
61549       {
61550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61551       };
61552     }
61553   }
61554
61555 }
61556
61557
61558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
61559   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61560   std::string *arg2 = 0 ;
61561   Dali::Property::Value *arg3 = 0 ;
61562
61563   arg1 = (Dali::Toolkit::Builder *)jarg1;
61564   if (!jarg2) {
61565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61566     return ;
61567   }
61568   std::string arg2_str(jarg2);
61569   arg2 = &arg2_str;
61570   arg3 = (Dali::Property::Value *)jarg3;
61571   if (!arg3) {
61572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
61573     return ;
61574   }
61575   {
61576     try {
61577       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
61578     } catch (std::out_of_range& e) {
61579       {
61580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61581       };
61582     } catch (std::exception& e) {
61583       {
61584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61585       };
61586     } catch (Dali::DaliException e) {
61587       {
61588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61589       };
61590     } catch (...) {
61591       {
61592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61593       };
61594     }
61595   }
61596
61597
61598   //argout typemap for const std::string&
61599
61600 }
61601
61602
61603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
61604   void * jresult ;
61605   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61606   Dali::Property::Map *result = 0 ;
61607
61608   arg1 = (Dali::Toolkit::Builder *)jarg1;
61609   {
61610     try {
61611       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
61612     } catch (std::out_of_range& e) {
61613       {
61614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61615       };
61616     } catch (std::exception& e) {
61617       {
61618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61619       };
61620     } catch (Dali::DaliException e) {
61621       {
61622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61623       };
61624     } catch (...) {
61625       {
61626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61627       };
61628     }
61629   }
61630
61631   jresult = (void *)result;
61632   return jresult;
61633 }
61634
61635
61636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
61637   void * jresult ;
61638   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61639   std::string *arg2 = 0 ;
61640   Dali::Property::Value *result = 0 ;
61641
61642   arg1 = (Dali::Toolkit::Builder *)jarg1;
61643   if (!jarg2) {
61644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61645     return 0;
61646   }
61647   std::string arg2_str(jarg2);
61648   arg2 = &arg2_str;
61649   {
61650     try {
61651       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
61652     } catch (std::out_of_range& e) {
61653       {
61654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61655       };
61656     } catch (std::exception& e) {
61657       {
61658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61659       };
61660     } catch (Dali::DaliException e) {
61661       {
61662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61663       };
61664     } catch (...) {
61665       {
61666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61667       };
61668     }
61669   }
61670
61671   jresult = (void *)result;
61672
61673   //argout typemap for const std::string&
61674
61675   return jresult;
61676 }
61677
61678
61679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
61680   void * jresult ;
61681   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61682   std::string *arg2 = 0 ;
61683   Dali::Animation result;
61684
61685   arg1 = (Dali::Toolkit::Builder *)jarg1;
61686   if (!jarg2) {
61687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61688     return 0;
61689   }
61690   std::string arg2_str(jarg2);
61691   arg2 = &arg2_str;
61692   {
61693     try {
61694       result = (arg1)->CreateAnimation((std::string const &)*arg2);
61695     } catch (std::out_of_range& e) {
61696       {
61697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61698       };
61699     } catch (std::exception& e) {
61700       {
61701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61702       };
61703     } catch (Dali::DaliException e) {
61704       {
61705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61706       };
61707     } catch (...) {
61708       {
61709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61710       };
61711     }
61712   }
61713
61714   jresult = new Dali::Animation((const Dali::Animation &)result);
61715
61716   //argout typemap for const std::string&
61717
61718   return jresult;
61719 }
61720
61721
61722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61723   void * jresult ;
61724   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61725   std::string *arg2 = 0 ;
61726   Dali::Property::Map *arg3 = 0 ;
61727   Dali::Animation result;
61728
61729   arg1 = (Dali::Toolkit::Builder *)jarg1;
61730   if (!jarg2) {
61731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61732     return 0;
61733   }
61734   std::string arg2_str(jarg2);
61735   arg2 = &arg2_str;
61736   arg3 = (Dali::Property::Map *)jarg3;
61737   if (!arg3) {
61738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61739     return 0;
61740   }
61741   {
61742     try {
61743       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61744     } catch (std::out_of_range& e) {
61745       {
61746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61747       };
61748     } catch (std::exception& e) {
61749       {
61750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61751       };
61752     } catch (Dali::DaliException e) {
61753       {
61754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61755       };
61756     } catch (...) {
61757       {
61758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61759       };
61760     }
61761   }
61762
61763   jresult = new Dali::Animation((const Dali::Animation &)result);
61764
61765   //argout typemap for const std::string&
61766
61767   return jresult;
61768 }
61769
61770
61771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
61772   void * jresult ;
61773   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61774   std::string *arg2 = 0 ;
61775   Dali::Actor arg3 ;
61776   Dali::Actor *argp3 ;
61777   Dali::Animation result;
61778
61779   arg1 = (Dali::Toolkit::Builder *)jarg1;
61780   if (!jarg2) {
61781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61782     return 0;
61783   }
61784   std::string arg2_str(jarg2);
61785   arg2 = &arg2_str;
61786   argp3 = (Dali::Actor *)jarg3;
61787   if (!argp3) {
61788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61789     return 0;
61790   }
61791   arg3 = *argp3;
61792   {
61793     try {
61794       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
61795     } catch (std::out_of_range& e) {
61796       {
61797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61798       };
61799     } catch (std::exception& e) {
61800       {
61801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61802       };
61803     } catch (Dali::DaliException e) {
61804       {
61805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61806       };
61807     } catch (...) {
61808       {
61809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61810       };
61811     }
61812   }
61813
61814   jresult = new Dali::Animation((const Dali::Animation &)result);
61815
61816   //argout typemap for const std::string&
61817
61818   return jresult;
61819 }
61820
61821
61822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
61823   void * jresult ;
61824   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61825   std::string *arg2 = 0 ;
61826   Dali::Property::Map *arg3 = 0 ;
61827   Dali::Actor arg4 ;
61828   Dali::Actor *argp4 ;
61829   Dali::Animation result;
61830
61831   arg1 = (Dali::Toolkit::Builder *)jarg1;
61832   if (!jarg2) {
61833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61834     return 0;
61835   }
61836   std::string arg2_str(jarg2);
61837   arg2 = &arg2_str;
61838   arg3 = (Dali::Property::Map *)jarg3;
61839   if (!arg3) {
61840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61841     return 0;
61842   }
61843   argp4 = (Dali::Actor *)jarg4;
61844   if (!argp4) {
61845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61846     return 0;
61847   }
61848   arg4 = *argp4;
61849   {
61850     try {
61851       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
61852     } catch (std::out_of_range& e) {
61853       {
61854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61855       };
61856     } catch (std::exception& e) {
61857       {
61858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61859       };
61860     } catch (Dali::DaliException e) {
61861       {
61862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61863       };
61864     } catch (...) {
61865       {
61866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61867       };
61868     }
61869   }
61870
61871   jresult = new Dali::Animation((const Dali::Animation &)result);
61872
61873   //argout typemap for const std::string&
61874
61875   return jresult;
61876 }
61877
61878
61879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
61880   void * jresult ;
61881   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61882   std::string *arg2 = 0 ;
61883   Dali::BaseHandle 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   {
61893     try {
61894       result = (arg1)->Create((std::string const &)*arg2);
61895     } catch (std::out_of_range& e) {
61896       {
61897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61898       };
61899     } catch (std::exception& e) {
61900       {
61901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61902       };
61903     } catch (Dali::DaliException e) {
61904       {
61905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61906       };
61907     } catch (...) {
61908       {
61909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61910       };
61911     }
61912   }
61913
61914   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61915
61916   //argout typemap for const std::string&
61917
61918   return jresult;
61919 }
61920
61921
61922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61923   void * jresult ;
61924   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61925   std::string *arg2 = 0 ;
61926   Dali::Property::Map *arg3 = 0 ;
61927   Dali::BaseHandle result;
61928
61929   arg1 = (Dali::Toolkit::Builder *)jarg1;
61930   if (!jarg2) {
61931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61932     return 0;
61933   }
61934   std::string arg2_str(jarg2);
61935   arg2 = &arg2_str;
61936   arg3 = (Dali::Property::Map *)jarg3;
61937   if (!arg3) {
61938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61939     return 0;
61940   }
61941   {
61942     try {
61943       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61944     } catch (std::out_of_range& e) {
61945       {
61946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61947       };
61948     } catch (std::exception& e) {
61949       {
61950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61951       };
61952     } catch (Dali::DaliException e) {
61953       {
61954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61955       };
61956     } catch (...) {
61957       {
61958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61959       };
61960     }
61961   }
61962
61963   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61964
61965   //argout typemap for const std::string&
61966
61967   return jresult;
61968 }
61969
61970
61971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
61972   void * jresult ;
61973   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61974   std::string *arg2 = 0 ;
61975   Dali::BaseHandle result;
61976
61977   arg1 = (Dali::Toolkit::Builder *)jarg1;
61978   if (!jarg2) {
61979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61980     return 0;
61981   }
61982   std::string arg2_str(jarg2);
61983   arg2 = &arg2_str;
61984   {
61985     try {
61986       result = (arg1)->CreateFromJson((std::string const &)*arg2);
61987     } catch (std::out_of_range& e) {
61988       {
61989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61990       };
61991     } catch (std::exception& e) {
61992       {
61993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61994       };
61995     } catch (Dali::DaliException e) {
61996       {
61997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61998       };
61999     } catch (...) {
62000       {
62001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62002       };
62003     }
62004   }
62005
62006   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
62007
62008   //argout typemap for const std::string&
62009
62010   return jresult;
62011 }
62012
62013
62014 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
62015   unsigned int jresult ;
62016   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62017   std::string *arg2 = 0 ;
62018   Dali::Handle *arg3 = 0 ;
62019   bool result;
62020
62021   arg1 = (Dali::Toolkit::Builder *)jarg1;
62022   if (!jarg2) {
62023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62024     return 0;
62025   }
62026   std::string arg2_str(jarg2);
62027   arg2 = &arg2_str;
62028   arg3 = (Dali::Handle *)jarg3;
62029   if (!arg3) {
62030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
62031     return 0;
62032   }
62033   {
62034     try {
62035       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
62036     } catch (std::out_of_range& e) {
62037       {
62038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62039       };
62040     } catch (std::exception& e) {
62041       {
62042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62043       };
62044     } catch (Dali::DaliException e) {
62045       {
62046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62047       };
62048     } catch (...) {
62049       {
62050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62051       };
62052     }
62053   }
62054
62055   jresult = result;
62056
62057   //argout typemap for const std::string&
62058
62059   return jresult;
62060 }
62061
62062
62063 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
62064   unsigned int jresult ;
62065   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62066   Dali::Handle *arg2 = 0 ;
62067   std::string *arg3 = 0 ;
62068   bool result;
62069
62070   arg1 = (Dali::Toolkit::Builder *)jarg1;
62071   arg2 = (Dali::Handle *)jarg2;
62072   if (!arg2) {
62073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
62074     return 0;
62075   }
62076   if (!jarg3) {
62077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62078     return 0;
62079   }
62080   std::string arg3_str(jarg3);
62081   arg3 = &arg3_str;
62082   {
62083     try {
62084       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
62085     } catch (std::out_of_range& e) {
62086       {
62087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62088       };
62089     } catch (std::exception& e) {
62090       {
62091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62092       };
62093     } catch (Dali::DaliException e) {
62094       {
62095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62096       };
62097     } catch (...) {
62098       {
62099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62100       };
62101     }
62102   }
62103
62104   jresult = result;
62105
62106   //argout typemap for const std::string&
62107
62108   return jresult;
62109 }
62110
62111
62112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
62113   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62114   Dali::Actor arg2 ;
62115   Dali::Actor *argp2 ;
62116
62117   arg1 = (Dali::Toolkit::Builder *)jarg1;
62118   argp2 = (Dali::Actor *)jarg2;
62119   if (!argp2) {
62120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62121     return ;
62122   }
62123   arg2 = *argp2;
62124   {
62125     try {
62126       (arg1)->AddActors(arg2);
62127     } catch (std::out_of_range& e) {
62128       {
62129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62130       };
62131     } catch (std::exception& e) {
62132       {
62133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62134       };
62135     } catch (Dali::DaliException e) {
62136       {
62137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62138       };
62139     } catch (...) {
62140       {
62141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62142       };
62143     }
62144   }
62145
62146 }
62147
62148
62149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
62150   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62151   std::string *arg2 = 0 ;
62152   Dali::Actor arg3 ;
62153   Dali::Actor *argp3 ;
62154
62155   arg1 = (Dali::Toolkit::Builder *)jarg1;
62156   if (!jarg2) {
62157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62158     return ;
62159   }
62160   std::string arg2_str(jarg2);
62161   arg2 = &arg2_str;
62162   argp3 = (Dali::Actor *)jarg3;
62163   if (!argp3) {
62164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62165     return ;
62166   }
62167   arg3 = *argp3;
62168   {
62169     try {
62170       (arg1)->AddActors((std::string const &)*arg2,arg3);
62171     } catch (std::out_of_range& e) {
62172       {
62173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62174       };
62175     } catch (std::exception& e) {
62176       {
62177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62178       };
62179     } catch (Dali::DaliException e) {
62180       {
62181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62182       };
62183     } catch (...) {
62184       {
62185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62186       };
62187     }
62188   }
62189
62190
62191   //argout typemap for const std::string&
62192
62193 }
62194
62195
62196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
62197   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62198   std::string *arg2 = 0 ;
62199
62200   arg1 = (Dali::Toolkit::Builder *)jarg1;
62201   if (!jarg2) {
62202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62203     return ;
62204   }
62205   std::string arg2_str(jarg2);
62206   arg2 = &arg2_str;
62207   {
62208     try {
62209       (arg1)->CreateRenderTask((std::string const &)*arg2);
62210     } catch (std::out_of_range& e) {
62211       {
62212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62213       };
62214     } catch (std::exception& e) {
62215       {
62216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62217       };
62218     } catch (Dali::DaliException e) {
62219       {
62220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62221       };
62222     } catch (...) {
62223       {
62224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62225       };
62226     }
62227   }
62228
62229
62230   //argout typemap for const std::string&
62231
62232 }
62233
62234
62235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
62236   void * jresult ;
62237   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62238   std::string *arg2 = 0 ;
62239   Dali::FrameBufferImage result;
62240
62241   arg1 = (Dali::Toolkit::Builder *)jarg1;
62242   if (!jarg2) {
62243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62244     return 0;
62245   }
62246   std::string arg2_str(jarg2);
62247   arg2 = &arg2_str;
62248   {
62249     try {
62250       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
62251     } catch (std::out_of_range& e) {
62252       {
62253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62254       };
62255     } catch (std::exception& e) {
62256       {
62257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62258       };
62259     } catch (Dali::DaliException e) {
62260       {
62261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62262       };
62263     } catch (...) {
62264       {
62265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62266       };
62267     }
62268   }
62269
62270   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
62271
62272   //argout typemap for const std::string&
62273
62274   return jresult;
62275 }
62276
62277
62278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
62279   void * jresult ;
62280   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62281   std::string *arg2 = 0 ;
62282   Dali::Path result;
62283
62284   arg1 = (Dali::Toolkit::Builder *)jarg1;
62285   if (!jarg2) {
62286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62287     return 0;
62288   }
62289   std::string arg2_str(jarg2);
62290   arg2 = &arg2_str;
62291   {
62292     try {
62293       result = (arg1)->GetPath((std::string const &)*arg2);
62294     } catch (std::out_of_range& e) {
62295       {
62296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62297       };
62298     } catch (std::exception& e) {
62299       {
62300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62301       };
62302     } catch (Dali::DaliException e) {
62303       {
62304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62305       };
62306     } catch (...) {
62307       {
62308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62309       };
62310     }
62311   }
62312
62313   jresult = new Dali::Path((const Dali::Path &)result);
62314
62315   //argout typemap for const std::string&
62316
62317   return jresult;
62318 }
62319
62320
62321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
62322   void * jresult ;
62323   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62324   std::string *arg2 = 0 ;
62325   Dali::PathConstrainer result;
62326
62327   arg1 = (Dali::Toolkit::Builder *)jarg1;
62328   if (!jarg2) {
62329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62330     return 0;
62331   }
62332   std::string arg2_str(jarg2);
62333   arg2 = &arg2_str;
62334   {
62335     try {
62336       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
62337     } catch (std::out_of_range& e) {
62338       {
62339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62340       };
62341     } catch (std::exception& e) {
62342       {
62343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62344       };
62345     } catch (Dali::DaliException e) {
62346       {
62347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62348       };
62349     } catch (...) {
62350       {
62351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62352       };
62353     }
62354   }
62355
62356   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
62357
62358   //argout typemap for const std::string&
62359
62360   return jresult;
62361 }
62362
62363
62364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
62365   void * jresult ;
62366   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62367   std::string *arg2 = 0 ;
62368   Dali::LinearConstrainer result;
62369
62370   arg1 = (Dali::Toolkit::Builder *)jarg1;
62371   if (!jarg2) {
62372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62373     return 0;
62374   }
62375   std::string arg2_str(jarg2);
62376   arg2 = &arg2_str;
62377   {
62378     try {
62379       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
62380     } catch (std::out_of_range& e) {
62381       {
62382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62383       };
62384     } catch (std::exception& e) {
62385       {
62386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62387       };
62388     } catch (Dali::DaliException e) {
62389       {
62390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62391       };
62392     } catch (...) {
62393       {
62394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62395       };
62396     }
62397   }
62398
62399   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
62400
62401   //argout typemap for const std::string&
62402
62403   return jresult;
62404 }
62405
62406
62407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
62408   void * jresult ;
62409   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62410   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
62411
62412   arg1 = (Dali::Toolkit::Builder *)jarg1;
62413   {
62414     try {
62415       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
62416     } catch (std::out_of_range& e) {
62417       {
62418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62419       };
62420     } catch (std::exception& e) {
62421       {
62422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62423       };
62424     } catch (Dali::DaliException e) {
62425       {
62426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62427       };
62428     } catch (...) {
62429       {
62430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62431       };
62432     }
62433   }
62434
62435   jresult = (void *)result;
62436   return jresult;
62437 }
62438
62439
62440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
62441   void * jresult ;
62442   Dali::Toolkit::TransitionData *result = 0 ;
62443
62444   {
62445     try {
62446       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
62447     } catch (std::out_of_range& e) {
62448       {
62449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62450       };
62451     } catch (std::exception& e) {
62452       {
62453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62454       };
62455     } catch (Dali::DaliException e) {
62456       {
62457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62458       };
62459     } catch (...) {
62460       {
62461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62462       };
62463     }
62464   }
62465
62466   jresult = (void *)result;
62467   return jresult;
62468 }
62469
62470
62471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
62472   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62473
62474   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62475   {
62476     try {
62477       delete arg1;
62478     } catch (std::out_of_range& e) {
62479       {
62480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62481       };
62482     } catch (std::exception& e) {
62483       {
62484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62485       };
62486     } catch (Dali::DaliException e) {
62487       {
62488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62489       };
62490     } catch (...) {
62491       {
62492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62493       };
62494     }
62495   }
62496
62497 }
62498
62499
62500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
62501   void * jresult ;
62502   Dali::Property::Map *arg1 = 0 ;
62503   Dali::Toolkit::TransitionData result;
62504
62505   arg1 = (Dali::Property::Map *)jarg1;
62506   if (!arg1) {
62507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62508     return 0;
62509   }
62510   {
62511     try {
62512       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
62513     } catch (std::out_of_range& e) {
62514       {
62515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62516       };
62517     } catch (std::exception& e) {
62518       {
62519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62520       };
62521     } catch (Dali::DaliException e) {
62522       {
62523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62524       };
62525     } catch (...) {
62526       {
62527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62528       };
62529     }
62530   }
62531
62532   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62533   return jresult;
62534 }
62535
62536
62537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
62538   void * jresult ;
62539   Dali::Property::Array *arg1 = 0 ;
62540   Dali::Toolkit::TransitionData result;
62541
62542   arg1 = (Dali::Property::Array *)jarg1;
62543   if (!arg1) {
62544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
62545     return 0;
62546   }
62547   {
62548     try {
62549       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
62550     } catch (std::out_of_range& e) {
62551       {
62552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62553       };
62554     } catch (std::exception& e) {
62555       {
62556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62557       };
62558     } catch (Dali::DaliException e) {
62559       {
62560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62561       };
62562     } catch (...) {
62563       {
62564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62565       };
62566     }
62567   }
62568
62569   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62570   return jresult;
62571 }
62572
62573
62574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
62575   void * jresult ;
62576   Dali::BaseHandle arg1 ;
62577   Dali::BaseHandle *argp1 ;
62578   Dali::Toolkit::TransitionData result;
62579
62580   argp1 = (Dali::BaseHandle *)jarg1;
62581   if (!argp1) {
62582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62583     return 0;
62584   }
62585   arg1 = *argp1;
62586   {
62587     try {
62588       result = Dali::Toolkit::TransitionData::DownCast(arg1);
62589     } catch (std::out_of_range& e) {
62590       {
62591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62592       };
62593     } catch (std::exception& e) {
62594       {
62595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62596       };
62597     } catch (Dali::DaliException e) {
62598       {
62599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62600       };
62601     } catch (...) {
62602       {
62603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62604       };
62605     }
62606   }
62607
62608   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62609   return jresult;
62610 }
62611
62612
62613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
62614   void * jresult ;
62615   Dali::Toolkit::TransitionData *arg1 = 0 ;
62616   Dali::Toolkit::TransitionData *result = 0 ;
62617
62618   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62619   if (!arg1) {
62620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62621     return 0;
62622   }
62623   {
62624     try {
62625       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
62626     } catch (std::out_of_range& e) {
62627       {
62628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62629       };
62630     } catch (std::exception& e) {
62631       {
62632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62633       };
62634     } catch (Dali::DaliException e) {
62635       {
62636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62637       };
62638     } catch (...) {
62639       {
62640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62641       };
62642     }
62643   }
62644
62645   jresult = (void *)result;
62646   return jresult;
62647 }
62648
62649
62650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
62651   void * jresult ;
62652   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62653   Dali::Toolkit::TransitionData *arg2 = 0 ;
62654   Dali::Toolkit::TransitionData *result = 0 ;
62655
62656   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62657   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
62658   if (!arg2) {
62659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62660     return 0;
62661   }
62662   {
62663     try {
62664       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
62665     } catch (std::out_of_range& e) {
62666       {
62667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62668       };
62669     } catch (std::exception& e) {
62670       {
62671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62672       };
62673     } catch (Dali::DaliException e) {
62674       {
62675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62676       };
62677     } catch (...) {
62678       {
62679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62680       };
62681     }
62682   }
62683
62684   jresult = (void *)result;
62685   return jresult;
62686 }
62687
62688
62689 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
62690   unsigned long jresult ;
62691   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62692   size_t result;
62693
62694   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62695   {
62696     try {
62697       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
62698     } catch (std::out_of_range& e) {
62699       {
62700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62701       };
62702     } catch (std::exception& e) {
62703       {
62704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62705       };
62706     } catch (Dali::DaliException e) {
62707       {
62708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62709       };
62710     } catch (...) {
62711       {
62712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62713       };
62714     }
62715   }
62716
62717   jresult = (unsigned long)result;
62718   return jresult;
62719 }
62720
62721
62722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
62723   void * jresult ;
62724   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62725   size_t arg2 ;
62726   Dali::Property::Map result;
62727
62728   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62729   arg2 = (size_t)jarg2;
62730   {
62731     try {
62732       result = (arg1)->GetAnimatorAt(arg2);
62733     } catch (std::out_of_range& e) {
62734       {
62735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62736       };
62737     } catch (std::exception& e) {
62738       {
62739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62740       };
62741     } catch (Dali::DaliException e) {
62742       {
62743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62744       };
62745     } catch (...) {
62746       {
62747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62748       };
62749     }
62750   }
62751
62752   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
62753   return jresult;
62754 }
62755
62756
62757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_2(void * jarg1) {
62758   void * jresult ;
62759   Dali::Toolkit::Internal::TransitionData *arg1 = (Dali::Toolkit::Internal::TransitionData *) 0 ;
62760   Dali::Toolkit::TransitionData *result = 0 ;
62761
62762   arg1 = (Dali::Toolkit::Internal::TransitionData *)jarg1;
62763   {
62764     try {
62765       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData(arg1);
62766     } catch (std::out_of_range& e) {
62767       {
62768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62769       };
62770     } catch (std::exception& e) {
62771       {
62772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62773       };
62774     } catch (Dali::DaliException e) {
62775       {
62776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62777       };
62778     } catch (...) {
62779       {
62780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62781       };
62782     }
62783   }
62784
62785   jresult = (void *)result;
62786   return jresult;
62787 }
62788
62789
62790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
62791   int jresult ;
62792   int result;
62793
62794   {
62795     try {
62796       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
62797     } catch (std::out_of_range& e) {
62798       {
62799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62800       };
62801     } catch (std::exception& e) {
62802       {
62803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62804       };
62805     } catch (Dali::DaliException e) {
62806       {
62807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62808       };
62809     } catch (...) {
62810       {
62811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62812       };
62813     }
62814   }
62815
62816   jresult = (int)result;
62817   return jresult;
62818 }
62819
62820
62821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
62822   int jresult ;
62823   int result;
62824
62825   {
62826     try {
62827       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
62828     } catch (std::out_of_range& e) {
62829       {
62830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62831       };
62832     } catch (std::exception& e) {
62833       {
62834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62835       };
62836     } catch (Dali::DaliException e) {
62837       {
62838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62839       };
62840     } catch (...) {
62841       {
62842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62843       };
62844     }
62845   }
62846
62847   jresult = (int)result;
62848   return jresult;
62849 }
62850
62851
62852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
62853   int jresult ;
62854   int result;
62855
62856   {
62857     try {
62858       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
62859     } catch (std::out_of_range& e) {
62860       {
62861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62862       };
62863     } catch (std::exception& e) {
62864       {
62865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62866       };
62867     } catch (Dali::DaliException e) {
62868       {
62869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62870       };
62871     } catch (...) {
62872       {
62873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62874       };
62875     }
62876   }
62877
62878   jresult = (int)result;
62879   return jresult;
62880 }
62881
62882
62883 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
62884   int jresult ;
62885   int result;
62886
62887   {
62888     try {
62889       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
62890     } catch (std::out_of_range& e) {
62891       {
62892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62893       };
62894     } catch (std::exception& e) {
62895       {
62896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62897       };
62898     } catch (Dali::DaliException e) {
62899       {
62900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62901       };
62902     } catch (...) {
62903       {
62904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62905       };
62906     }
62907   }
62908
62909   jresult = (int)result;
62910   return jresult;
62911 }
62912
62913
62914 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
62915   int jresult ;
62916   int result;
62917
62918   {
62919     try {
62920       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
62921     } catch (std::out_of_range& e) {
62922       {
62923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62924       };
62925     } catch (std::exception& e) {
62926       {
62927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62928       };
62929     } catch (Dali::DaliException e) {
62930       {
62931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62932       };
62933     } catch (...) {
62934       {
62935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62936       };
62937     }
62938   }
62939
62940   jresult = (int)result;
62941   return jresult;
62942 }
62943
62944
62945 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
62946   int jresult ;
62947   int result;
62948
62949   {
62950     try {
62951       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
62952     } catch (std::out_of_range& e) {
62953       {
62954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62955       };
62956     } catch (std::exception& e) {
62957       {
62958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62959       };
62960     } catch (Dali::DaliException e) {
62961       {
62962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62963       };
62964     } catch (...) {
62965       {
62966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62967       };
62968     }
62969   }
62970
62971   jresult = (int)result;
62972   return jresult;
62973 }
62974
62975
62976 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
62977   int jresult ;
62978   int result;
62979
62980   {
62981     try {
62982       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
62983     } catch (std::out_of_range& e) {
62984       {
62985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62986       };
62987     } catch (std::exception& e) {
62988       {
62989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62990       };
62991     } catch (Dali::DaliException e) {
62992       {
62993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62994       };
62995     } catch (...) {
62996       {
62997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62998       };
62999     }
63000   }
63001
63002   jresult = (int)result;
63003   return jresult;
63004 }
63005
63006
63007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
63008   int jresult ;
63009   int result;
63010
63011   {
63012     try {
63013       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
63014     } catch (std::out_of_range& e) {
63015       {
63016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63017       };
63018     } catch (std::exception& e) {
63019       {
63020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63021       };
63022     } catch (Dali::DaliException e) {
63023       {
63024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63025       };
63026     } catch (...) {
63027       {
63028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63029       };
63030     }
63031   }
63032
63033   jresult = (int)result;
63034   return jresult;
63035 }
63036
63037
63038 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
63039   int jresult ;
63040   int result;
63041
63042   {
63043     try {
63044       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
63045     } catch (std::out_of_range& e) {
63046       {
63047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63048       };
63049     } catch (std::exception& e) {
63050       {
63051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63052       };
63053     } catch (Dali::DaliException e) {
63054       {
63055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63056       };
63057     } catch (...) {
63058       {
63059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63060       };
63061     }
63062   }
63063
63064   jresult = (int)result;
63065   return jresult;
63066 }
63067
63068
63069 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
63070   int jresult ;
63071   int result;
63072
63073   {
63074     try {
63075       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
63076     } catch (std::out_of_range& e) {
63077       {
63078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63079       };
63080     } catch (std::exception& e) {
63081       {
63082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63083       };
63084     } catch (Dali::DaliException e) {
63085       {
63086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63087       };
63088     } catch (...) {
63089       {
63090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63091       };
63092     }
63093   }
63094
63095   jresult = (int)result;
63096   return jresult;
63097 }
63098
63099
63100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
63101   int jresult ;
63102   int result;
63103
63104   {
63105     try {
63106       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
63107     } catch (std::out_of_range& e) {
63108       {
63109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63110       };
63111     } catch (std::exception& e) {
63112       {
63113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63114       };
63115     } catch (Dali::DaliException e) {
63116       {
63117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63118       };
63119     } catch (...) {
63120       {
63121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63122       };
63123     }
63124   }
63125
63126   jresult = (int)result;
63127   return jresult;
63128 }
63129
63130
63131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
63132   int jresult ;
63133   int result;
63134
63135   {
63136     try {
63137       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
63138     } catch (std::out_of_range& e) {
63139       {
63140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63141       };
63142     } catch (std::exception& e) {
63143       {
63144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63145       };
63146     } catch (Dali::DaliException e) {
63147       {
63148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63149       };
63150     } catch (...) {
63151       {
63152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63153       };
63154     }
63155   }
63156
63157   jresult = (int)result;
63158   return jresult;
63159 }
63160
63161
63162 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
63163   int jresult ;
63164   int result;
63165
63166   {
63167     try {
63168       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
63169     } catch (std::out_of_range& e) {
63170       {
63171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63172       };
63173     } catch (std::exception& e) {
63174       {
63175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63176       };
63177     } catch (Dali::DaliException e) {
63178       {
63179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63180       };
63181     } catch (...) {
63182       {
63183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63184       };
63185     }
63186   }
63187
63188   jresult = (int)result;
63189   return jresult;
63190 }
63191
63192
63193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
63194   int jresult ;
63195   int result;
63196
63197   {
63198     try {
63199       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
63200     } catch (std::out_of_range& e) {
63201       {
63202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63203       };
63204     } catch (std::exception& e) {
63205       {
63206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63207       };
63208     } catch (Dali::DaliException e) {
63209       {
63210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63211       };
63212     } catch (...) {
63213       {
63214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63215       };
63216     }
63217   }
63218
63219   jresult = (int)result;
63220   return jresult;
63221 }
63222
63223
63224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
63225   void * jresult ;
63226   Dali::Toolkit::Control result;
63227
63228   {
63229     try {
63230       result = Dali::Toolkit::Internal::Control::New();
63231     } catch (std::out_of_range& e) {
63232       {
63233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63234       };
63235     } catch (std::exception& e) {
63236       {
63237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63238       };
63239     } catch (Dali::DaliException e) {
63240       {
63241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63242       };
63243     } catch (...) {
63244       {
63245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63246       };
63247     }
63248   }
63249
63250   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63251   return jresult;
63252 }
63253
63254
63255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
63256   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63257   std::string *arg2 = 0 ;
63258
63259   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63260   if (!jarg2) {
63261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63262     return ;
63263   }
63264   std::string arg2_str(jarg2);
63265   arg2 = &arg2_str;
63266   {
63267     try {
63268       (arg1)->SetStyleName((std::string const &)*arg2);
63269     } catch (std::out_of_range& e) {
63270       {
63271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63272       };
63273     } catch (std::exception& e) {
63274       {
63275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63276       };
63277     } catch (Dali::DaliException e) {
63278       {
63279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63280       };
63281     } catch (...) {
63282       {
63283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63284       };
63285     }
63286   }
63287
63288
63289   //argout typemap for const std::string&
63290
63291 }
63292
63293
63294 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
63295   char * jresult ;
63296   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63297   std::string *result = 0 ;
63298
63299   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63300   {
63301     try {
63302       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
63303     } catch (std::out_of_range& e) {
63304       {
63305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63306       };
63307     } catch (std::exception& e) {
63308       {
63309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63310       };
63311     } catch (Dali::DaliException e) {
63312       {
63313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63314       };
63315     } catch (...) {
63316       {
63317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63318       };
63319     }
63320   }
63321
63322   jresult = SWIG_csharp_string_callback(result->c_str());
63323   return jresult;
63324 }
63325
63326
63327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
63328   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63329   Dali::Vector4 *arg2 = 0 ;
63330
63331   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63332   arg2 = (Dali::Vector4 *)jarg2;
63333   if (!arg2) {
63334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63335     return ;
63336   }
63337   {
63338     try {
63339       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63340     } catch (std::out_of_range& e) {
63341       {
63342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63343       };
63344     } catch (std::exception& e) {
63345       {
63346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63347       };
63348     } catch (Dali::DaliException e) {
63349       {
63350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63351       };
63352     } catch (...) {
63353       {
63354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63355       };
63356     }
63357   }
63358
63359 }
63360
63361
63362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
63363   void * jresult ;
63364   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63365   Dali::Vector4 result;
63366
63367   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63368   {
63369     try {
63370       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
63371     } catch (std::out_of_range& e) {
63372       {
63373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63374       };
63375     } catch (std::exception& e) {
63376       {
63377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63378       };
63379     } catch (Dali::DaliException e) {
63380       {
63381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63382       };
63383     } catch (...) {
63384       {
63385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63386       };
63387     }
63388   }
63389
63390   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
63391   return jresult;
63392 }
63393
63394
63395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
63396   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63397   Dali::Image arg2 ;
63398   Dali::Image *argp2 ;
63399
63400   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63401   argp2 = (Dali::Image *)jarg2;
63402   if (!argp2) {
63403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
63404     return ;
63405   }
63406   arg2 = *argp2;
63407   {
63408     try {
63409       (arg1)->SetBackgroundImage(arg2);
63410     } catch (std::out_of_range& e) {
63411       {
63412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63413       };
63414     } catch (std::exception& e) {
63415       {
63416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63417       };
63418     } catch (Dali::DaliException e) {
63419       {
63420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63421       };
63422     } catch (...) {
63423       {
63424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63425       };
63426     }
63427   }
63428
63429 }
63430
63431
63432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
63433   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63434   Dali::Property::Map *arg2 = 0 ;
63435
63436   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63437   arg2 = (Dali::Property::Map *)jarg2;
63438   if (!arg2) {
63439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
63440     return ;
63441   }
63442   {
63443     try {
63444       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
63445     } catch (std::out_of_range& e) {
63446       {
63447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63448       };
63449     } catch (std::exception& e) {
63450       {
63451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63452       };
63453     } catch (Dali::DaliException e) {
63454       {
63455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63456       };
63457     } catch (...) {
63458       {
63459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63460       };
63461     }
63462   }
63463
63464 }
63465
63466
63467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
63468   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63469
63470   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63471   {
63472     try {
63473       (arg1)->ClearBackground();
63474     } catch (std::out_of_range& e) {
63475       {
63476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63477       };
63478     } catch (std::exception& e) {
63479       {
63480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63481       };
63482     } catch (Dali::DaliException e) {
63483       {
63484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63485       };
63486     } catch (...) {
63487       {
63488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63489       };
63490     }
63491   }
63492
63493 }
63494
63495
63496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
63497   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63498   Dali::Gesture::Type arg2 ;
63499
63500   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63501   arg2 = (Dali::Gesture::Type)jarg2;
63502   {
63503     try {
63504       (arg1)->EnableGestureDetection(arg2);
63505     } catch (std::out_of_range& e) {
63506       {
63507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63508       };
63509     } catch (std::exception& e) {
63510       {
63511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63512       };
63513     } catch (Dali::DaliException e) {
63514       {
63515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63516       };
63517     } catch (...) {
63518       {
63519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63520       };
63521     }
63522   }
63523
63524 }
63525
63526
63527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
63528   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63529   Dali::Gesture::Type arg2 ;
63530
63531   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63532   arg2 = (Dali::Gesture::Type)jarg2;
63533   {
63534     try {
63535       (arg1)->DisableGestureDetection(arg2);
63536     } catch (std::out_of_range& e) {
63537       {
63538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63539       };
63540     } catch (std::exception& e) {
63541       {
63542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63543       };
63544     } catch (Dali::DaliException e) {
63545       {
63546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63547       };
63548     } catch (...) {
63549       {
63550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63551       };
63552     }
63553   }
63554
63555 }
63556
63557
63558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
63559   void * jresult ;
63560   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63561   Dali::PinchGestureDetector result;
63562
63563   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63564   {
63565     try {
63566       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
63567     } catch (std::out_of_range& e) {
63568       {
63569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63570       };
63571     } catch (std::exception& e) {
63572       {
63573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63574       };
63575     } catch (Dali::DaliException e) {
63576       {
63577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63578       };
63579     } catch (...) {
63580       {
63581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63582       };
63583     }
63584   }
63585
63586   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63587   return jresult;
63588 }
63589
63590
63591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
63592   void * jresult ;
63593   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63594   Dali::PanGestureDetector result;
63595
63596   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63597   {
63598     try {
63599       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
63600     } catch (std::out_of_range& e) {
63601       {
63602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63603       };
63604     } catch (std::exception& e) {
63605       {
63606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63607       };
63608     } catch (Dali::DaliException e) {
63609       {
63610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63611       };
63612     } catch (...) {
63613       {
63614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63615       };
63616     }
63617   }
63618
63619   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63620   return jresult;
63621 }
63622
63623
63624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
63625   void * jresult ;
63626   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63627   Dali::TapGestureDetector result;
63628
63629   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63630   {
63631     try {
63632       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
63633     } catch (std::out_of_range& e) {
63634       {
63635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63636       };
63637     } catch (std::exception& e) {
63638       {
63639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63640       };
63641     } catch (Dali::DaliException e) {
63642       {
63643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63644       };
63645     } catch (...) {
63646       {
63647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63648       };
63649     }
63650   }
63651
63652   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63653   return jresult;
63654 }
63655
63656
63657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
63658   void * jresult ;
63659   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63660   Dali::LongPressGestureDetector result;
63661
63662   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63663   {
63664     try {
63665       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
63666     } catch (std::out_of_range& e) {
63667       {
63668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63669       };
63670     } catch (std::exception& e) {
63671       {
63672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63673       };
63674     } catch (Dali::DaliException e) {
63675       {
63676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63677       };
63678     } catch (...) {
63679       {
63680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63681       };
63682     }
63683   }
63684
63685   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63686   return jresult;
63687 }
63688
63689
63690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
63691   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63692   bool arg2 ;
63693
63694   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63695   arg2 = jarg2 ? true : false;
63696   {
63697     try {
63698       (arg1)->SetKeyboardNavigationSupport(arg2);
63699     } catch (std::out_of_range& e) {
63700       {
63701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63702       };
63703     } catch (std::exception& e) {
63704       {
63705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63706       };
63707     } catch (Dali::DaliException e) {
63708       {
63709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63710       };
63711     } catch (...) {
63712       {
63713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63714       };
63715     }
63716   }
63717
63718 }
63719
63720
63721 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
63722   unsigned int jresult ;
63723   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63724   bool result;
63725
63726   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63727   {
63728     try {
63729       result = (bool)(arg1)->IsKeyboardNavigationSupported();
63730     } catch (std::out_of_range& e) {
63731       {
63732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63733       };
63734     } catch (std::exception& e) {
63735       {
63736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63737       };
63738     } catch (Dali::DaliException e) {
63739       {
63740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63741       };
63742     } catch (...) {
63743       {
63744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63745       };
63746     }
63747   }
63748
63749   jresult = result;
63750   return jresult;
63751 }
63752
63753
63754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
63755   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63756
63757   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63758   {
63759     try {
63760       (arg1)->SetKeyInputFocus();
63761     } catch (std::out_of_range& e) {
63762       {
63763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63764       };
63765     } catch (std::exception& e) {
63766       {
63767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63768       };
63769     } catch (Dali::DaliException e) {
63770       {
63771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63772       };
63773     } catch (...) {
63774       {
63775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63776       };
63777     }
63778   }
63779
63780 }
63781
63782
63783 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
63784   unsigned int jresult ;
63785   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63786   bool result;
63787
63788   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63789   {
63790     try {
63791       result = (bool)(arg1)->HasKeyInputFocus();
63792     } catch (std::out_of_range& e) {
63793       {
63794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63795       };
63796     } catch (std::exception& e) {
63797       {
63798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63799       };
63800     } catch (Dali::DaliException e) {
63801       {
63802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63803       };
63804     } catch (...) {
63805       {
63806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63807       };
63808     }
63809   }
63810
63811   jresult = result;
63812   return jresult;
63813 }
63814
63815
63816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
63817   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63818
63819   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63820   {
63821     try {
63822       (arg1)->ClearKeyInputFocus();
63823     } catch (std::out_of_range& e) {
63824       {
63825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63826       };
63827     } catch (std::exception& e) {
63828       {
63829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63830       };
63831     } catch (Dali::DaliException e) {
63832       {
63833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63834       };
63835     } catch (...) {
63836       {
63837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63838       };
63839     }
63840   }
63841
63842 }
63843
63844
63845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
63846   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63847   bool arg2 ;
63848
63849   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63850   arg2 = jarg2 ? true : false;
63851   {
63852     try {
63853       (arg1)->SetAsKeyboardFocusGroup(arg2);
63854     } catch (std::out_of_range& e) {
63855       {
63856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63857       };
63858     } catch (std::exception& e) {
63859       {
63860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63861       };
63862     } catch (Dali::DaliException e) {
63863       {
63864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63865       };
63866     } catch (...) {
63867       {
63868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63869       };
63870     }
63871   }
63872
63873 }
63874
63875
63876 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
63877   unsigned int jresult ;
63878   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63879   bool result;
63880
63881   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63882   {
63883     try {
63884       result = (bool)(arg1)->IsKeyboardFocusGroup();
63885     } catch (std::out_of_range& e) {
63886       {
63887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63888       };
63889     } catch (std::exception& e) {
63890       {
63891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63892       };
63893     } catch (Dali::DaliException e) {
63894       {
63895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63896       };
63897     } catch (...) {
63898       {
63899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63900       };
63901     }
63902   }
63903
63904   jresult = result;
63905   return jresult;
63906 }
63907
63908
63909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_AccessibilityActivate(void * jarg1) {
63910   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63911
63912   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63913   {
63914     try {
63915       (arg1)->AccessibilityActivate();
63916     } catch (std::out_of_range& e) {
63917       {
63918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63919       };
63920     } catch (std::exception& e) {
63921       {
63922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63923       };
63924     } catch (Dali::DaliException e) {
63925       {
63926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63927       };
63928     } catch (...) {
63929       {
63930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63931       };
63932     }
63933   }
63934
63935 }
63936
63937
63938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_KeyboardEnter(void * jarg1) {
63939   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63940
63941   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63942   {
63943     try {
63944       (arg1)->KeyboardEnter();
63945     } catch (std::out_of_range& e) {
63946       {
63947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63948       };
63949     } catch (std::exception& e) {
63950       {
63951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63952       };
63953     } catch (Dali::DaliException e) {
63954       {
63955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63956       };
63957     } catch (...) {
63958       {
63959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63960       };
63961     }
63962   }
63963
63964 }
63965
63966
63967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
63968   void * jresult ;
63969   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63970   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
63971
63972   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63973   {
63974     try {
63975       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
63976     } catch (std::out_of_range& e) {
63977       {
63978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63979       };
63980     } catch (std::exception& e) {
63981       {
63982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63983       };
63984     } catch (Dali::DaliException e) {
63985       {
63986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63987       };
63988     } catch (...) {
63989       {
63990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63991       };
63992     }
63993   }
63994
63995   jresult = (void *)result;
63996   return jresult;
63997 }
63998
63999
64000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
64001   void * jresult ;
64002   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64003   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
64004
64005   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64006   {
64007     try {
64008       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
64009     } catch (std::out_of_range& e) {
64010       {
64011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64012       };
64013     } catch (std::exception& e) {
64014       {
64015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64016       };
64017     } catch (Dali::DaliException e) {
64018       {
64019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64020       };
64021     } catch (...) {
64022       {
64023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64024       };
64025     }
64026   }
64027
64028   jresult = (void *)result;
64029   return jresult;
64030 }
64031
64032
64033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
64034   void * jresult ;
64035   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64036   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
64037
64038   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64039   {
64040     try {
64041       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
64042     } catch (std::out_of_range& e) {
64043       {
64044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64045       };
64046     } catch (std::exception& e) {
64047       {
64048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64049       };
64050     } catch (Dali::DaliException e) {
64051       {
64052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64053       };
64054     } catch (...) {
64055       {
64056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64057       };
64058     }
64059   }
64060
64061   jresult = (void *)result;
64062   return jresult;
64063 }
64064
64065
64066 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_EmitKeyEventSignal(void * jarg1, void * jarg2) {
64067   unsigned int jresult ;
64068   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64069   Dali::KeyEvent *arg2 = 0 ;
64070   bool result;
64071
64072   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64073   arg2 = (Dali::KeyEvent *)jarg2;
64074   if (!arg2) {
64075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64076     return 0;
64077   }
64078   {
64079     try {
64080       result = (bool)(arg1)->EmitKeyEventSignal((Dali::KeyEvent const &)*arg2);
64081     } catch (std::out_of_range& e) {
64082       {
64083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64084       };
64085     } catch (std::exception& e) {
64086       {
64087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64088       };
64089     } catch (Dali::DaliException e) {
64090       {
64091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64092       };
64093     } catch (...) {
64094       {
64095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64096       };
64097     }
64098   }
64099
64100   jresult = result;
64101   return jresult;
64102 }
64103
64104
64105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
64106   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64107   int arg2 ;
64108   SwigDirector_ViewImpl *darg = 0;
64109
64110   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64111   arg2 = (int)jarg2;
64112   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64113   {
64114     try {
64115       (darg)->OnStageConnection(arg2);
64116     } catch (std::out_of_range& e) {
64117       {
64118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64119       };
64120     } catch (std::exception& e) {
64121       {
64122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64123       };
64124     } catch (Dali::DaliException e) {
64125       {
64126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64127       };
64128     } catch (...) {
64129       {
64130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64131       };
64132     }
64133   }
64134
64135 }
64136
64137
64138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
64139   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64140   int arg2 ;
64141   SwigDirector_ViewImpl *darg = 0;
64142
64143   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64144   arg2 = (int)jarg2;
64145   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64146   {
64147     try {
64148       (darg)->OnStageConnectionSwigPublic(arg2);
64149     } catch (std::out_of_range& e) {
64150       {
64151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64152       };
64153     } catch (std::exception& e) {
64154       {
64155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64156       };
64157     } catch (Dali::DaliException e) {
64158       {
64159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64160       };
64161     } catch (...) {
64162       {
64163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64164       };
64165     }
64166   }
64167
64168 }
64169
64170
64171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
64172   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64173   SwigDirector_ViewImpl *darg = 0;
64174
64175   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64176   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64177   {
64178     try {
64179       (darg)->OnStageDisconnection();
64180     } catch (std::out_of_range& e) {
64181       {
64182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64183       };
64184     } catch (std::exception& e) {
64185       {
64186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64187       };
64188     } catch (Dali::DaliException e) {
64189       {
64190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64191       };
64192     } catch (...) {
64193       {
64194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64195       };
64196     }
64197   }
64198
64199 }
64200
64201
64202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
64203   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64204   SwigDirector_ViewImpl *darg = 0;
64205
64206   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64207   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64208   {
64209     try {
64210       (darg)->OnStageDisconnectionSwigPublic();
64211     } catch (std::out_of_range& e) {
64212       {
64213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64214       };
64215     } catch (std::exception& e) {
64216       {
64217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64218       };
64219     } catch (Dali::DaliException e) {
64220       {
64221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64222       };
64223     } catch (...) {
64224       {
64225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64226       };
64227     }
64228   }
64229
64230 }
64231
64232
64233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
64234   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64235   Dali::Actor *arg2 = 0 ;
64236   SwigDirector_ViewImpl *darg = 0;
64237
64238   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64239   arg2 = (Dali::Actor *)jarg2;
64240   if (!arg2) {
64241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64242     return ;
64243   }
64244   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64245   {
64246     try {
64247       (darg)->OnChildAdd(*arg2);
64248     } catch (std::out_of_range& e) {
64249       {
64250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64251       };
64252     } catch (std::exception& e) {
64253       {
64254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64255       };
64256     } catch (Dali::DaliException e) {
64257       {
64258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64259       };
64260     } catch (...) {
64261       {
64262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64263       };
64264     }
64265   }
64266
64267 }
64268
64269
64270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64271   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64272   Dali::Actor *arg2 = 0 ;
64273   SwigDirector_ViewImpl *darg = 0;
64274
64275   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64276   arg2 = (Dali::Actor *)jarg2;
64277   if (!arg2) {
64278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64279     return ;
64280   }
64281   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64282   {
64283     try {
64284       (darg)->OnChildAddSwigPublic(*arg2);
64285     } catch (std::out_of_range& e) {
64286       {
64287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64288       };
64289     } catch (std::exception& e) {
64290       {
64291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64292       };
64293     } catch (Dali::DaliException e) {
64294       {
64295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64296       };
64297     } catch (...) {
64298       {
64299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64300       };
64301     }
64302   }
64303
64304 }
64305
64306
64307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
64308   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64309   Dali::Actor *arg2 = 0 ;
64310   SwigDirector_ViewImpl *darg = 0;
64311
64312   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64313   arg2 = (Dali::Actor *)jarg2;
64314   if (!arg2) {
64315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64316     return ;
64317   }
64318   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64319   {
64320     try {
64321       (darg)->OnChildRemove(*arg2);
64322     } catch (std::out_of_range& e) {
64323       {
64324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64325       };
64326     } catch (std::exception& e) {
64327       {
64328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64329       };
64330     } catch (Dali::DaliException e) {
64331       {
64332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64333       };
64334     } catch (...) {
64335       {
64336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64337       };
64338     }
64339   }
64340
64341 }
64342
64343
64344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64345   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64346   Dali::Actor *arg2 = 0 ;
64347   SwigDirector_ViewImpl *darg = 0;
64348
64349   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64350   arg2 = (Dali::Actor *)jarg2;
64351   if (!arg2) {
64352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64353     return ;
64354   }
64355   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64356   {
64357     try {
64358       (darg)->OnChildRemoveSwigPublic(*arg2);
64359     } catch (std::out_of_range& e) {
64360       {
64361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64362       };
64363     } catch (std::exception& e) {
64364       {
64365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64366       };
64367     } catch (Dali::DaliException e) {
64368       {
64369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64370       };
64371     } catch (...) {
64372       {
64373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64374       };
64375     }
64376   }
64377
64378 }
64379
64380
64381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
64382   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64383   Dali::Property::Index arg2 ;
64384   Dali::Property::Value arg3 ;
64385   Dali::Property::Value *argp3 ;
64386   SwigDirector_ViewImpl *darg = 0;
64387
64388   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64389   arg2 = (Dali::Property::Index)jarg2;
64390   argp3 = (Dali::Property::Value *)jarg3;
64391   if (!argp3) {
64392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64393     return ;
64394   }
64395   arg3 = *argp3;
64396   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64397   {
64398     try {
64399       (darg)->OnPropertySet(arg2,arg3);
64400     } catch (std::out_of_range& e) {
64401       {
64402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64403       };
64404     } catch (std::exception& e) {
64405       {
64406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64407       };
64408     } catch (Dali::DaliException e) {
64409       {
64410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64411       };
64412     } catch (...) {
64413       {
64414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64415       };
64416     }
64417   }
64418
64419 }
64420
64421
64422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
64423   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64424   Dali::Property::Index arg2 ;
64425   Dali::Property::Value arg3 ;
64426   Dali::Property::Value *argp3 ;
64427   SwigDirector_ViewImpl *darg = 0;
64428
64429   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64430   arg2 = (Dali::Property::Index)jarg2;
64431   argp3 = (Dali::Property::Value *)jarg3;
64432   if (!argp3) {
64433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64434     return ;
64435   }
64436   arg3 = *argp3;
64437   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64438   {
64439     try {
64440       (darg)->OnPropertySetSwigPublic(arg2,arg3);
64441     } catch (std::out_of_range& e) {
64442       {
64443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64444       };
64445     } catch (std::exception& e) {
64446       {
64447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64448       };
64449     } catch (Dali::DaliException e) {
64450       {
64451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64452       };
64453     } catch (...) {
64454       {
64455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64456       };
64457     }
64458   }
64459
64460 }
64461
64462
64463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
64464   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64465   Dali::Vector3 *arg2 = 0 ;
64466   SwigDirector_ViewImpl *darg = 0;
64467
64468   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64469   arg2 = (Dali::Vector3 *)jarg2;
64470   if (!arg2) {
64471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64472     return ;
64473   }
64474   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64475   {
64476     try {
64477       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
64478     } catch (std::out_of_range& e) {
64479       {
64480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64481       };
64482     } catch (std::exception& e) {
64483       {
64484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64485       };
64486     } catch (Dali::DaliException e) {
64487       {
64488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64489       };
64490     } catch (...) {
64491       {
64492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64493       };
64494     }
64495   }
64496
64497 }
64498
64499
64500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64501   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64502   Dali::Vector3 *arg2 = 0 ;
64503   SwigDirector_ViewImpl *darg = 0;
64504
64505   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64506   arg2 = (Dali::Vector3 *)jarg2;
64507   if (!arg2) {
64508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64509     return ;
64510   }
64511   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64512   {
64513     try {
64514       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
64515     } catch (std::out_of_range& e) {
64516       {
64517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64518       };
64519     } catch (std::exception& e) {
64520       {
64521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64522       };
64523     } catch (Dali::DaliException e) {
64524       {
64525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64526       };
64527     } catch (...) {
64528       {
64529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64530       };
64531     }
64532   }
64533
64534 }
64535
64536
64537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
64538   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64539   Dali::Animation *arg2 = 0 ;
64540   Dali::Vector3 *arg3 = 0 ;
64541   SwigDirector_ViewImpl *darg = 0;
64542
64543   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64544   arg2 = (Dali::Animation *)jarg2;
64545   if (!arg2) {
64546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64547     return ;
64548   }
64549   arg3 = (Dali::Vector3 *)jarg3;
64550   if (!arg3) {
64551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64552     return ;
64553   }
64554   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64555   {
64556     try {
64557       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
64558     } catch (std::out_of_range& e) {
64559       {
64560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64561       };
64562     } catch (std::exception& e) {
64563       {
64564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64565       };
64566     } catch (Dali::DaliException e) {
64567       {
64568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64569       };
64570     } catch (...) {
64571       {
64572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64573       };
64574     }
64575   }
64576
64577 }
64578
64579
64580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64581   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64582   Dali::Animation *arg2 = 0 ;
64583   Dali::Vector3 *arg3 = 0 ;
64584   SwigDirector_ViewImpl *darg = 0;
64585
64586   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64587   arg2 = (Dali::Animation *)jarg2;
64588   if (!arg2) {
64589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64590     return ;
64591   }
64592   arg3 = (Dali::Vector3 *)jarg3;
64593   if (!arg3) {
64594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64595     return ;
64596   }
64597   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64598   {
64599     try {
64600       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
64601     } catch (std::out_of_range& e) {
64602       {
64603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64604       };
64605     } catch (std::exception& e) {
64606       {
64607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64608       };
64609     } catch (Dali::DaliException e) {
64610       {
64611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64612       };
64613     } catch (...) {
64614       {
64615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64616       };
64617     }
64618   }
64619
64620 }
64621
64622
64623 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
64624   unsigned int jresult ;
64625   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64626   Dali::TouchEvent *arg2 = 0 ;
64627   SwigDirector_ViewImpl *darg = 0;
64628   bool result;
64629
64630   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64631   arg2 = (Dali::TouchEvent *)jarg2;
64632   if (!arg2) {
64633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64634     return 0;
64635   }
64636   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64637   {
64638     try {
64639       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
64640     } catch (std::out_of_range& e) {
64641       {
64642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64643       };
64644     } catch (std::exception& e) {
64645       {
64646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64647       };
64648     } catch (Dali::DaliException e) {
64649       {
64650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64651       };
64652     } catch (...) {
64653       {
64654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64655       };
64656     }
64657   }
64658
64659   jresult = result;
64660   return jresult;
64661 }
64662
64663
64664 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64665   unsigned int jresult ;
64666   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64667   Dali::TouchEvent *arg2 = 0 ;
64668   SwigDirector_ViewImpl *darg = 0;
64669   bool result;
64670
64671   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64672   arg2 = (Dali::TouchEvent *)jarg2;
64673   if (!arg2) {
64674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64675     return 0;
64676   }
64677   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64678   {
64679     try {
64680       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
64681     } catch (std::out_of_range& e) {
64682       {
64683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64684       };
64685     } catch (std::exception& e) {
64686       {
64687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64688       };
64689     } catch (Dali::DaliException e) {
64690       {
64691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64692       };
64693     } catch (...) {
64694       {
64695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64696       };
64697     }
64698   }
64699
64700   jresult = result;
64701   return jresult;
64702 }
64703
64704
64705 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
64706   unsigned int jresult ;
64707   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64708   Dali::HoverEvent *arg2 = 0 ;
64709   SwigDirector_ViewImpl *darg = 0;
64710   bool result;
64711
64712   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64713   arg2 = (Dali::HoverEvent *)jarg2;
64714   if (!arg2) {
64715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64716     return 0;
64717   }
64718   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64719   {
64720     try {
64721       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
64722     } catch (std::out_of_range& e) {
64723       {
64724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64725       };
64726     } catch (std::exception& e) {
64727       {
64728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64729       };
64730     } catch (Dali::DaliException e) {
64731       {
64732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64733       };
64734     } catch (...) {
64735       {
64736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64737       };
64738     }
64739   }
64740
64741   jresult = result;
64742   return jresult;
64743 }
64744
64745
64746 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64747   unsigned int jresult ;
64748   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64749   Dali::HoverEvent *arg2 = 0 ;
64750   SwigDirector_ViewImpl *darg = 0;
64751   bool result;
64752
64753   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64754   arg2 = (Dali::HoverEvent *)jarg2;
64755   if (!arg2) {
64756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64757     return 0;
64758   }
64759   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64760   {
64761     try {
64762       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
64763     } catch (std::out_of_range& e) {
64764       {
64765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64766       };
64767     } catch (std::exception& e) {
64768       {
64769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64770       };
64771     } catch (Dali::DaliException e) {
64772       {
64773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64774       };
64775     } catch (...) {
64776       {
64777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64778       };
64779     }
64780   }
64781
64782   jresult = result;
64783   return jresult;
64784 }
64785
64786
64787 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
64788   unsigned int jresult ;
64789   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64790   Dali::KeyEvent *arg2 = 0 ;
64791   SwigDirector_ViewImpl *darg = 0;
64792   bool result;
64793
64794   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64795   arg2 = (Dali::KeyEvent *)jarg2;
64796   if (!arg2) {
64797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64798     return 0;
64799   }
64800   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64801   {
64802     try {
64803       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
64804     } catch (std::out_of_range& e) {
64805       {
64806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64807       };
64808     } catch (std::exception& e) {
64809       {
64810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64811       };
64812     } catch (Dali::DaliException e) {
64813       {
64814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64815       };
64816     } catch (...) {
64817       {
64818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64819       };
64820     }
64821   }
64822
64823   jresult = result;
64824   return jresult;
64825 }
64826
64827
64828 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64829   unsigned int jresult ;
64830   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64831   Dali::KeyEvent *arg2 = 0 ;
64832   SwigDirector_ViewImpl *darg = 0;
64833   bool result;
64834
64835   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64836   arg2 = (Dali::KeyEvent *)jarg2;
64837   if (!arg2) {
64838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64839     return 0;
64840   }
64841   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64842   {
64843     try {
64844       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
64845     } catch (std::out_of_range& e) {
64846       {
64847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64848       };
64849     } catch (std::exception& e) {
64850       {
64851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64852       };
64853     } catch (Dali::DaliException e) {
64854       {
64855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64856       };
64857     } catch (...) {
64858       {
64859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64860       };
64861     }
64862   }
64863
64864   jresult = result;
64865   return jresult;
64866 }
64867
64868
64869 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
64870   unsigned int jresult ;
64871   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64872   Dali::WheelEvent *arg2 = 0 ;
64873   SwigDirector_ViewImpl *darg = 0;
64874   bool result;
64875
64876   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64877   arg2 = (Dali::WheelEvent *)jarg2;
64878   if (!arg2) {
64879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64880     return 0;
64881   }
64882   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64883   {
64884     try {
64885       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
64886     } catch (std::out_of_range& e) {
64887       {
64888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64889       };
64890     } catch (std::exception& e) {
64891       {
64892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64893       };
64894     } catch (Dali::DaliException e) {
64895       {
64896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64897       };
64898     } catch (...) {
64899       {
64900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64901       };
64902     }
64903   }
64904
64905   jresult = result;
64906   return jresult;
64907 }
64908
64909
64910 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64911   unsigned int jresult ;
64912   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64913   Dali::WheelEvent *arg2 = 0 ;
64914   SwigDirector_ViewImpl *darg = 0;
64915   bool result;
64916
64917   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64918   arg2 = (Dali::WheelEvent *)jarg2;
64919   if (!arg2) {
64920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64921     return 0;
64922   }
64923   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64924   {
64925     try {
64926       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
64927     } catch (std::out_of_range& e) {
64928       {
64929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64930       };
64931     } catch (std::exception& e) {
64932       {
64933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64934       };
64935     } catch (Dali::DaliException e) {
64936       {
64937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64938       };
64939     } catch (...) {
64940       {
64941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64942       };
64943     }
64944   }
64945
64946   jresult = result;
64947   return jresult;
64948 }
64949
64950
64951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
64952   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64953   Dali::Vector2 *arg2 = 0 ;
64954   Dali::RelayoutContainer *arg3 = 0 ;
64955   SwigDirector_ViewImpl *darg = 0;
64956
64957   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64958   arg2 = (Dali::Vector2 *)jarg2;
64959   if (!arg2) {
64960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
64961     return ;
64962   }
64963   arg3 = (Dali::RelayoutContainer *)jarg3;
64964   if (!arg3) {
64965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
64966     return ;
64967   }
64968   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64969   {
64970     try {
64971       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
64972     } catch (std::out_of_range& e) {
64973       {
64974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64975       };
64976     } catch (std::exception& e) {
64977       {
64978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64979       };
64980     } catch (Dali::DaliException e) {
64981       {
64982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64983       };
64984     } catch (...) {
64985       {
64986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64987       };
64988     }
64989   }
64990
64991 }
64992
64993
64994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64995   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64996   Dali::Vector2 *arg2 = 0 ;
64997   Dali::RelayoutContainer *arg3 = 0 ;
64998   SwigDirector_ViewImpl *darg = 0;
64999
65000   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65001   arg2 = (Dali::Vector2 *)jarg2;
65002   if (!arg2) {
65003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
65004     return ;
65005   }
65006   arg3 = (Dali::RelayoutContainer *)jarg3;
65007   if (!arg3) {
65008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
65009     return ;
65010   }
65011   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65012   {
65013     try {
65014       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
65015     } catch (std::out_of_range& e) {
65016       {
65017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65018       };
65019     } catch (std::exception& e) {
65020       {
65021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65022       };
65023     } catch (Dali::DaliException e) {
65024       {
65025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65026       };
65027     } catch (...) {
65028       {
65029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65030       };
65031     }
65032   }
65033
65034 }
65035
65036
65037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
65038   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65039   Dali::ResizePolicy::Type arg2 ;
65040   Dali::Dimension::Type arg3 ;
65041   SwigDirector_ViewImpl *darg = 0;
65042
65043   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65044   arg2 = (Dali::ResizePolicy::Type)jarg2;
65045   arg3 = (Dali::Dimension::Type)jarg3;
65046   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65047   {
65048     try {
65049       (darg)->OnSetResizePolicy(arg2,arg3);
65050     } catch (std::out_of_range& e) {
65051       {
65052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65053       };
65054     } catch (std::exception& e) {
65055       {
65056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65057       };
65058     } catch (Dali::DaliException e) {
65059       {
65060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65061       };
65062     } catch (...) {
65063       {
65064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65065       };
65066     }
65067   }
65068
65069 }
65070
65071
65072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
65073   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65074   Dali::ResizePolicy::Type arg2 ;
65075   Dali::Dimension::Type arg3 ;
65076   SwigDirector_ViewImpl *darg = 0;
65077
65078   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65079   arg2 = (Dali::ResizePolicy::Type)jarg2;
65080   arg3 = (Dali::Dimension::Type)jarg3;
65081   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65082   {
65083     try {
65084       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
65085     } catch (std::out_of_range& e) {
65086       {
65087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65088       };
65089     } catch (std::exception& e) {
65090       {
65091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65092       };
65093     } catch (Dali::DaliException e) {
65094       {
65095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65096       };
65097     } catch (...) {
65098       {
65099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65100       };
65101     }
65102   }
65103
65104 }
65105
65106
65107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
65108   void * jresult ;
65109   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65110   SwigDirector_ViewImpl *darg = 0;
65111   Dali::Vector3 result;
65112
65113   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65114   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65115   {
65116     try {
65117       result = (darg)->GetNaturalSize();
65118     } catch (std::out_of_range& e) {
65119       {
65120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65121       };
65122     } catch (std::exception& e) {
65123       {
65124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65125       };
65126     } catch (Dali::DaliException e) {
65127       {
65128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65129       };
65130     } catch (...) {
65131       {
65132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65133       };
65134     }
65135   }
65136
65137   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65138   return jresult;
65139 }
65140
65141
65142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
65143   void * jresult ;
65144   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65145   SwigDirector_ViewImpl *darg = 0;
65146   Dali::Vector3 result;
65147
65148   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65149   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65150   {
65151     try {
65152       result = (darg)->GetNaturalSizeSwigPublic();
65153     } catch (std::out_of_range& e) {
65154       {
65155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65156       };
65157     } catch (std::exception& e) {
65158       {
65159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65160       };
65161     } catch (Dali::DaliException e) {
65162       {
65163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65164       };
65165     } catch (...) {
65166       {
65167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65168       };
65169     }
65170   }
65171
65172   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65173   return jresult;
65174 }
65175
65176
65177 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
65178   float jresult ;
65179   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65180   Dali::Actor *arg2 = 0 ;
65181   Dali::Dimension::Type arg3 ;
65182   SwigDirector_ViewImpl *darg = 0;
65183   float result;
65184
65185   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65186   arg2 = (Dali::Actor *)jarg2;
65187   if (!arg2) {
65188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65189     return 0;
65190   }
65191   arg3 = (Dali::Dimension::Type)jarg3;
65192   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65193   {
65194     try {
65195       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
65196     } catch (std::out_of_range& e) {
65197       {
65198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65199       };
65200     } catch (std::exception& e) {
65201       {
65202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65203       };
65204     } catch (Dali::DaliException e) {
65205       {
65206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65207       };
65208     } catch (...) {
65209       {
65210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65211       };
65212     }
65213   }
65214
65215   jresult = result;
65216   return jresult;
65217 }
65218
65219
65220 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65221   float jresult ;
65222   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65223   Dali::Actor *arg2 = 0 ;
65224   Dali::Dimension::Type arg3 ;
65225   SwigDirector_ViewImpl *darg = 0;
65226   float result;
65227
65228   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65229   arg2 = (Dali::Actor *)jarg2;
65230   if (!arg2) {
65231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65232     return 0;
65233   }
65234   arg3 = (Dali::Dimension::Type)jarg3;
65235   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65236   {
65237     try {
65238       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
65239     } catch (std::out_of_range& e) {
65240       {
65241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65242       };
65243     } catch (std::exception& e) {
65244       {
65245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65246       };
65247     } catch (Dali::DaliException e) {
65248       {
65249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65250       };
65251     } catch (...) {
65252       {
65253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65254       };
65255     }
65256   }
65257
65258   jresult = result;
65259   return jresult;
65260 }
65261
65262
65263 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
65264   float jresult ;
65265   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65266   float arg2 ;
65267   SwigDirector_ViewImpl *darg = 0;
65268   float result;
65269
65270   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65271   arg2 = (float)jarg2;
65272   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65273   {
65274     try {
65275       result = (float)(darg)->GetHeightForWidth(arg2);
65276     } catch (std::out_of_range& e) {
65277       {
65278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65279       };
65280     } catch (std::exception& e) {
65281       {
65282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65283       };
65284     } catch (Dali::DaliException e) {
65285       {
65286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65287       };
65288     } catch (...) {
65289       {
65290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65291       };
65292     }
65293   }
65294
65295   jresult = result;
65296   return jresult;
65297 }
65298
65299
65300 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
65301   float jresult ;
65302   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65303   float arg2 ;
65304   SwigDirector_ViewImpl *darg = 0;
65305   float result;
65306
65307   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65308   arg2 = (float)jarg2;
65309   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65310   {
65311     try {
65312       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
65313     } catch (std::out_of_range& e) {
65314       {
65315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65316       };
65317     } catch (std::exception& e) {
65318       {
65319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65320       };
65321     } catch (Dali::DaliException e) {
65322       {
65323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65324       };
65325     } catch (...) {
65326       {
65327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65328       };
65329     }
65330   }
65331
65332   jresult = result;
65333   return jresult;
65334 }
65335
65336
65337 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
65338   float jresult ;
65339   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65340   float arg2 ;
65341   SwigDirector_ViewImpl *darg = 0;
65342   float result;
65343
65344   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65345   arg2 = (float)jarg2;
65346   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65347   {
65348     try {
65349       result = (float)(darg)->GetWidthForHeight(arg2);
65350     } catch (std::out_of_range& e) {
65351       {
65352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65353       };
65354     } catch (std::exception& e) {
65355       {
65356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65357       };
65358     } catch (Dali::DaliException e) {
65359       {
65360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65361       };
65362     } catch (...) {
65363       {
65364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65365       };
65366     }
65367   }
65368
65369   jresult = result;
65370   return jresult;
65371 }
65372
65373
65374 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
65375   float jresult ;
65376   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65377   float arg2 ;
65378   SwigDirector_ViewImpl *darg = 0;
65379   float result;
65380
65381   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65382   arg2 = (float)jarg2;
65383   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65384   {
65385     try {
65386       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
65387     } catch (std::out_of_range& e) {
65388       {
65389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65390       };
65391     } catch (std::exception& e) {
65392       {
65393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65394       };
65395     } catch (Dali::DaliException e) {
65396       {
65397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65398       };
65399     } catch (...) {
65400       {
65401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65402       };
65403     }
65404   }
65405
65406   jresult = result;
65407   return jresult;
65408 }
65409
65410
65411 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
65412   unsigned int jresult ;
65413   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65414   Dali::Dimension::Type arg2 ;
65415   SwigDirector_ViewImpl *darg = 0;
65416   bool result;
65417
65418   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65419   arg2 = (Dali::Dimension::Type)jarg2;
65420   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65421   {
65422     try {
65423       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
65424     } catch (std::out_of_range& e) {
65425       {
65426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65427       };
65428     } catch (std::exception& e) {
65429       {
65430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65431       };
65432     } catch (Dali::DaliException e) {
65433       {
65434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65435       };
65436     } catch (...) {
65437       {
65438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65439       };
65440     }
65441   }
65442
65443   jresult = result;
65444   return jresult;
65445 }
65446
65447
65448 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
65449   unsigned int jresult ;
65450   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65451   Dali::Dimension::Type arg2 ;
65452   SwigDirector_ViewImpl *darg = 0;
65453   bool result;
65454
65455   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65456   arg2 = (Dali::Dimension::Type)jarg2;
65457   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65458   {
65459     try {
65460       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
65461     } catch (std::out_of_range& e) {
65462       {
65463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65464       };
65465     } catch (std::exception& e) {
65466       {
65467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65468       };
65469     } catch (Dali::DaliException e) {
65470       {
65471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65472       };
65473     } catch (...) {
65474       {
65475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65476       };
65477     }
65478   }
65479
65480   jresult = result;
65481   return jresult;
65482 }
65483
65484
65485 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
65486   unsigned int jresult ;
65487   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65488   SwigDirector_ViewImpl *darg = 0;
65489   bool result;
65490
65491   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65492   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65493   {
65494     try {
65495       result = (bool)(darg)->RelayoutDependentOnChildren();
65496     } catch (std::out_of_range& e) {
65497       {
65498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65499       };
65500     } catch (std::exception& e) {
65501       {
65502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65503       };
65504     } catch (Dali::DaliException e) {
65505       {
65506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65507       };
65508     } catch (...) {
65509       {
65510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65511       };
65512     }
65513   }
65514
65515   jresult = result;
65516   return jresult;
65517 }
65518
65519
65520 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
65521   unsigned int jresult ;
65522   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65523   SwigDirector_ViewImpl *darg = 0;
65524   bool result;
65525
65526   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65527   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65528   {
65529     try {
65530       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
65531     } catch (std::out_of_range& e) {
65532       {
65533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65534       };
65535     } catch (std::exception& e) {
65536       {
65537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65538       };
65539     } catch (Dali::DaliException e) {
65540       {
65541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65542       };
65543     } catch (...) {
65544       {
65545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65546       };
65547     }
65548   }
65549
65550   jresult = result;
65551   return jresult;
65552 }
65553
65554
65555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
65556   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65557   Dali::Dimension::Type arg2 ;
65558   SwigDirector_ViewImpl *darg = 0;
65559
65560   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65561   arg2 = (Dali::Dimension::Type)jarg2;
65562   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65563   {
65564     try {
65565       (darg)->OnCalculateRelayoutSize(arg2);
65566     } catch (std::out_of_range& e) {
65567       {
65568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65569       };
65570     } catch (std::exception& e) {
65571       {
65572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65573       };
65574     } catch (Dali::DaliException e) {
65575       {
65576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65577       };
65578     } catch (...) {
65579       {
65580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65581       };
65582     }
65583   }
65584
65585 }
65586
65587
65588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
65589   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65590   Dali::Dimension::Type arg2 ;
65591   SwigDirector_ViewImpl *darg = 0;
65592
65593   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65594   arg2 = (Dali::Dimension::Type)jarg2;
65595   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65596   {
65597     try {
65598       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
65599     } catch (std::out_of_range& e) {
65600       {
65601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65602       };
65603     } catch (std::exception& e) {
65604       {
65605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65606       };
65607     } catch (Dali::DaliException e) {
65608       {
65609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65610       };
65611     } catch (...) {
65612       {
65613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65614       };
65615     }
65616   }
65617
65618 }
65619
65620
65621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
65622   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65623   float arg2 ;
65624   Dali::Dimension::Type arg3 ;
65625   SwigDirector_ViewImpl *darg = 0;
65626
65627   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65628   arg2 = (float)jarg2;
65629   arg3 = (Dali::Dimension::Type)jarg3;
65630   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65631   {
65632     try {
65633       (darg)->OnLayoutNegotiated(arg2,arg3);
65634     } catch (std::out_of_range& e) {
65635       {
65636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65637       };
65638     } catch (std::exception& e) {
65639       {
65640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65641       };
65642     } catch (Dali::DaliException e) {
65643       {
65644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65645       };
65646     } catch (...) {
65647       {
65648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65649       };
65650     }
65651   }
65652
65653 }
65654
65655
65656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
65657   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65658   float arg2 ;
65659   Dali::Dimension::Type arg3 ;
65660   SwigDirector_ViewImpl *darg = 0;
65661
65662   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65663   arg2 = (float)jarg2;
65664   arg3 = (Dali::Dimension::Type)jarg3;
65665   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65666   {
65667     try {
65668       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
65669     } catch (std::out_of_range& e) {
65670       {
65671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65672       };
65673     } catch (std::exception& e) {
65674       {
65675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65676       };
65677     } catch (Dali::DaliException e) {
65678       {
65679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65680       };
65681     } catch (...) {
65682       {
65683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65684       };
65685     }
65686   }
65687
65688 }
65689
65690
65691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
65692   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65693
65694   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65695   {
65696     try {
65697       (arg1)->OnInitialize();
65698     } catch (std::out_of_range& e) {
65699       {
65700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65701       };
65702     } catch (std::exception& e) {
65703       {
65704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65705       };
65706     } catch (Dali::DaliException e) {
65707       {
65708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65709       };
65710     } catch (...) {
65711       {
65712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65713       };
65714     }
65715   }
65716
65717 }
65718
65719
65720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
65721   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65722
65723   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65724   {
65725     try {
65726       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
65727     } catch (std::out_of_range& e) {
65728       {
65729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65730       };
65731     } catch (std::exception& e) {
65732       {
65733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65734       };
65735     } catch (Dali::DaliException e) {
65736       {
65737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65738       };
65739     } catch (...) {
65740       {
65741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65742       };
65743     }
65744   }
65745
65746 }
65747
65748
65749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
65750   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65751   Dali::Actor *arg2 = 0 ;
65752
65753   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65754   arg2 = (Dali::Actor *)jarg2;
65755   if (!arg2) {
65756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65757     return ;
65758   }
65759   {
65760     try {
65761       (arg1)->OnControlChildAdd(*arg2);
65762     } catch (std::out_of_range& e) {
65763       {
65764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65765       };
65766     } catch (std::exception& e) {
65767       {
65768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65769       };
65770     } catch (Dali::DaliException e) {
65771       {
65772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65773       };
65774     } catch (...) {
65775       {
65776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65777       };
65778     }
65779   }
65780
65781 }
65782
65783
65784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65785   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65786   Dali::Actor *arg2 = 0 ;
65787
65788   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65789   arg2 = (Dali::Actor *)jarg2;
65790   if (!arg2) {
65791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65792     return ;
65793   }
65794   {
65795     try {
65796       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
65797     } catch (std::out_of_range& e) {
65798       {
65799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65800       };
65801     } catch (std::exception& e) {
65802       {
65803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65804       };
65805     } catch (Dali::DaliException e) {
65806       {
65807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65808       };
65809     } catch (...) {
65810       {
65811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65812       };
65813     }
65814   }
65815
65816 }
65817
65818
65819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
65820   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65821   Dali::Actor *arg2 = 0 ;
65822
65823   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65824   arg2 = (Dali::Actor *)jarg2;
65825   if (!arg2) {
65826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65827     return ;
65828   }
65829   {
65830     try {
65831       (arg1)->OnControlChildRemove(*arg2);
65832     } catch (std::out_of_range& e) {
65833       {
65834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65835       };
65836     } catch (std::exception& e) {
65837       {
65838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65839       };
65840     } catch (Dali::DaliException e) {
65841       {
65842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65843       };
65844     } catch (...) {
65845       {
65846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65847       };
65848     }
65849   }
65850
65851 }
65852
65853
65854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65855   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65856   Dali::Actor *arg2 = 0 ;
65857
65858   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65859   arg2 = (Dali::Actor *)jarg2;
65860   if (!arg2) {
65861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65862     return ;
65863   }
65864   {
65865     try {
65866       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
65867     } catch (std::out_of_range& e) {
65868       {
65869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65870       };
65871     } catch (std::exception& e) {
65872       {
65873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65874       };
65875     } catch (Dali::DaliException e) {
65876       {
65877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65878       };
65879     } catch (...) {
65880       {
65881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65882       };
65883     }
65884   }
65885
65886 }
65887
65888
65889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
65890   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65891   Dali::Toolkit::StyleManager arg2 ;
65892   Dali::StyleChange::Type arg3 ;
65893   Dali::Toolkit::StyleManager *argp2 ;
65894
65895   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65896   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65897   if (!argp2) {
65898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65899     return ;
65900   }
65901   arg2 = *argp2;
65902   arg3 = (Dali::StyleChange::Type)jarg3;
65903   {
65904     try {
65905       (arg1)->OnStyleChange(arg2,arg3);
65906     } catch (std::out_of_range& e) {
65907       {
65908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65909       };
65910     } catch (std::exception& e) {
65911       {
65912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65913       };
65914     } catch (Dali::DaliException e) {
65915       {
65916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65917       };
65918     } catch (...) {
65919       {
65920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65921       };
65922     }
65923   }
65924
65925 }
65926
65927
65928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65929   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65930   Dali::Toolkit::StyleManager arg2 ;
65931   Dali::StyleChange::Type arg3 ;
65932   Dali::Toolkit::StyleManager *argp2 ;
65933
65934   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65935   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65936   if (!argp2) {
65937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65938     return ;
65939   }
65940   arg2 = *argp2;
65941   arg3 = (Dali::StyleChange::Type)jarg3;
65942   {
65943     try {
65944       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
65945     } catch (std::out_of_range& e) {
65946       {
65947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65948       };
65949     } catch (std::exception& e) {
65950       {
65951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65952       };
65953     } catch (Dali::DaliException e) {
65954       {
65955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65956       };
65957     } catch (...) {
65958       {
65959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65960       };
65961     }
65962   }
65963
65964 }
65965
65966
65967 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
65968   unsigned int jresult ;
65969   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65970   bool result;
65971
65972   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65973   {
65974     try {
65975       result = (bool)(arg1)->OnAccessibilityActivated();
65976     } catch (std::out_of_range& e) {
65977       {
65978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65979       };
65980     } catch (std::exception& e) {
65981       {
65982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65983       };
65984     } catch (Dali::DaliException e) {
65985       {
65986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65987       };
65988     } catch (...) {
65989       {
65990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65991       };
65992     }
65993   }
65994
65995   jresult = result;
65996   return jresult;
65997 }
65998
65999
66000 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
66001   unsigned int jresult ;
66002   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66003   bool result;
66004
66005   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66006   {
66007     try {
66008       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
66009     } catch (std::out_of_range& e) {
66010       {
66011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66012       };
66013     } catch (std::exception& e) {
66014       {
66015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66016       };
66017     } catch (Dali::DaliException e) {
66018       {
66019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66020       };
66021     } catch (...) {
66022       {
66023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66024       };
66025     }
66026   }
66027
66028   jresult = result;
66029   return jresult;
66030 }
66031
66032
66033 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
66034   unsigned int jresult ;
66035   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66036   Dali::PanGesture arg2 ;
66037   Dali::PanGesture *argp2 ;
66038   bool result;
66039
66040   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66041   argp2 = (Dali::PanGesture *)jarg2;
66042   if (!argp2) {
66043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
66044     return 0;
66045   }
66046   arg2 = *argp2;
66047   {
66048     try {
66049       result = (bool)(arg1)->OnAccessibilityPan(arg2);
66050     } catch (std::out_of_range& e) {
66051       {
66052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66053       };
66054     } catch (std::exception& e) {
66055       {
66056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66057       };
66058     } catch (Dali::DaliException e) {
66059       {
66060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66061       };
66062     } catch (...) {
66063       {
66064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66065       };
66066     }
66067   }
66068
66069   jresult = result;
66070   return jresult;
66071 }
66072
66073
66074 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66075   unsigned int jresult ;
66076   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66077   Dali::PanGesture arg2 ;
66078   Dali::PanGesture *argp2 ;
66079   bool result;
66080
66081   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66082   argp2 = (Dali::PanGesture *)jarg2;
66083   if (!argp2) {
66084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
66085     return 0;
66086   }
66087   arg2 = *argp2;
66088   {
66089     try {
66090       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
66091     } catch (std::out_of_range& e) {
66092       {
66093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66094       };
66095     } catch (std::exception& e) {
66096       {
66097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66098       };
66099     } catch (Dali::DaliException e) {
66100       {
66101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66102       };
66103     } catch (...) {
66104       {
66105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66106       };
66107     }
66108   }
66109
66110   jresult = result;
66111   return jresult;
66112 }
66113
66114
66115 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
66116   unsigned int jresult ;
66117   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66118   Dali::TouchEvent *arg2 = 0 ;
66119   bool result;
66120
66121   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66122   arg2 = (Dali::TouchEvent *)jarg2;
66123   if (!arg2) {
66124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
66125     return 0;
66126   }
66127   {
66128     try {
66129       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66130     } catch (std::out_of_range& e) {
66131       {
66132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66133       };
66134     } catch (std::exception& e) {
66135       {
66136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66137       };
66138     } catch (Dali::DaliException e) {
66139       {
66140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66141       };
66142     } catch (...) {
66143       {
66144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66145       };
66146     }
66147   }
66148
66149   jresult = result;
66150   return jresult;
66151 }
66152
66153
66154 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66155   unsigned int jresult ;
66156   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66157   Dali::TouchEvent *arg2 = 0 ;
66158   bool result;
66159
66160   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66161   arg2 = (Dali::TouchEvent *)jarg2;
66162   if (!arg2) {
66163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
66164     return 0;
66165   }
66166   {
66167     try {
66168       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66169     } catch (std::out_of_range& e) {
66170       {
66171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66172       };
66173     } catch (std::exception& e) {
66174       {
66175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66176       };
66177     } catch (Dali::DaliException e) {
66178       {
66179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66180       };
66181     } catch (...) {
66182       {
66183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66184       };
66185     }
66186   }
66187
66188   jresult = result;
66189   return jresult;
66190 }
66191
66192
66193 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
66194   unsigned int jresult ;
66195   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66196   bool arg2 ;
66197   bool result;
66198
66199   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66200   arg2 = jarg2 ? true : false;
66201   {
66202     try {
66203       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
66204     } catch (std::out_of_range& e) {
66205       {
66206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66207       };
66208     } catch (std::exception& e) {
66209       {
66210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66211       };
66212     } catch (Dali::DaliException e) {
66213       {
66214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66215       };
66216     } catch (...) {
66217       {
66218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66219       };
66220     }
66221   }
66222
66223   jresult = result;
66224   return jresult;
66225 }
66226
66227
66228 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
66229   unsigned int jresult ;
66230   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66231   bool arg2 ;
66232   bool result;
66233
66234   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66235   arg2 = jarg2 ? true : false;
66236   {
66237     try {
66238       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
66239     } catch (std::out_of_range& e) {
66240       {
66241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66242       };
66243     } catch (std::exception& e) {
66244       {
66245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66246       };
66247     } catch (Dali::DaliException e) {
66248       {
66249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66250       };
66251     } catch (...) {
66252       {
66253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66254       };
66255     }
66256   }
66257
66258   jresult = result;
66259   return jresult;
66260 }
66261
66262
66263 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
66264   unsigned int jresult ;
66265   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66266   bool result;
66267
66268   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66269   {
66270     try {
66271       result = (bool)(arg1)->OnAccessibilityZoom();
66272     } catch (std::out_of_range& e) {
66273       {
66274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66275       };
66276     } catch (std::exception& e) {
66277       {
66278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66279       };
66280     } catch (Dali::DaliException e) {
66281       {
66282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66283       };
66284     } catch (...) {
66285       {
66286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66287       };
66288     }
66289   }
66290
66291   jresult = result;
66292   return jresult;
66293 }
66294
66295
66296 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
66297   unsigned int jresult ;
66298   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66299   bool result;
66300
66301   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66302   {
66303     try {
66304       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
66305     } catch (std::out_of_range& e) {
66306       {
66307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66308       };
66309     } catch (std::exception& e) {
66310       {
66311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66312       };
66313     } catch (Dali::DaliException e) {
66314       {
66315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66316       };
66317     } catch (...) {
66318       {
66319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66320       };
66321     }
66322   }
66323
66324   jresult = result;
66325   return jresult;
66326 }
66327
66328
66329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
66330   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66331
66332   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66333   {
66334     try {
66335       (arg1)->OnKeyInputFocusGained();
66336     } catch (std::out_of_range& e) {
66337       {
66338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66339       };
66340     } catch (std::exception& e) {
66341       {
66342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66343       };
66344     } catch (Dali::DaliException e) {
66345       {
66346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66347       };
66348     } catch (...) {
66349       {
66350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66351       };
66352     }
66353   }
66354
66355 }
66356
66357
66358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
66359   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66360
66361   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66362   {
66363     try {
66364       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
66365     } catch (std::out_of_range& e) {
66366       {
66367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66368       };
66369     } catch (std::exception& e) {
66370       {
66371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66372       };
66373     } catch (Dali::DaliException e) {
66374       {
66375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66376       };
66377     } catch (...) {
66378       {
66379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66380       };
66381     }
66382   }
66383
66384 }
66385
66386
66387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
66388   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66389
66390   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66391   {
66392     try {
66393       (arg1)->OnKeyInputFocusLost();
66394     } catch (std::out_of_range& e) {
66395       {
66396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66397       };
66398     } catch (std::exception& e) {
66399       {
66400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66401       };
66402     } catch (Dali::DaliException e) {
66403       {
66404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66405       };
66406     } catch (...) {
66407       {
66408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66409       };
66410     }
66411   }
66412
66413 }
66414
66415
66416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
66417   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66418
66419   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66420   {
66421     try {
66422       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
66423     } catch (std::out_of_range& e) {
66424       {
66425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66426       };
66427     } catch (std::exception& e) {
66428       {
66429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66430       };
66431     } catch (Dali::DaliException e) {
66432       {
66433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66434       };
66435     } catch (...) {
66436       {
66437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66438       };
66439     }
66440   }
66441
66442 }
66443
66444
66445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66446   void * jresult ;
66447   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66448   Dali::Actor arg2 ;
66449   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66450   bool arg4 ;
66451   Dali::Actor *argp2 ;
66452   Dali::Actor result;
66453
66454   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66455   argp2 = (Dali::Actor *)jarg2;
66456   if (!argp2) {
66457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66458     return 0;
66459   }
66460   arg2 = *argp2;
66461   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66462   arg4 = jarg4 ? true : false;
66463   {
66464     try {
66465       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66466     } catch (std::out_of_range& e) {
66467       {
66468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66469       };
66470     } catch (std::exception& e) {
66471       {
66472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66473       };
66474     } catch (Dali::DaliException e) {
66475       {
66476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66477       };
66478     } catch (...) {
66479       {
66480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66481       };
66482     }
66483   }
66484
66485   jresult = new Dali::Actor((const Dali::Actor &)result);
66486   return jresult;
66487 }
66488
66489
66490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66491   void * jresult ;
66492   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66493   Dali::Actor arg2 ;
66494   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66495   bool arg4 ;
66496   Dali::Actor *argp2 ;
66497   Dali::Actor result;
66498
66499   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66500   argp2 = (Dali::Actor *)jarg2;
66501   if (!argp2) {
66502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66503     return 0;
66504   }
66505   arg2 = *argp2;
66506   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66507   arg4 = jarg4 ? true : false;
66508   {
66509     try {
66510       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66511     } catch (std::out_of_range& e) {
66512       {
66513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66514       };
66515     } catch (std::exception& e) {
66516       {
66517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66518       };
66519     } catch (Dali::DaliException e) {
66520       {
66521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66522       };
66523     } catch (...) {
66524       {
66525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66526       };
66527     }
66528   }
66529
66530   jresult = new Dali::Actor((const Dali::Actor &)result);
66531   return jresult;
66532 }
66533
66534
66535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
66536   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66537   Dali::Actor arg2 ;
66538   Dali::Actor *argp2 ;
66539
66540   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66541   argp2 = (Dali::Actor *)jarg2;
66542   if (!argp2) {
66543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66544     return ;
66545   }
66546   arg2 = *argp2;
66547   {
66548     try {
66549       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
66550     } catch (std::out_of_range& e) {
66551       {
66552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66553       };
66554     } catch (std::exception& e) {
66555       {
66556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66557       };
66558     } catch (Dali::DaliException e) {
66559       {
66560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66561       };
66562     } catch (...) {
66563       {
66564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66565       };
66566     }
66567   }
66568
66569 }
66570
66571
66572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66573   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66574   Dali::Actor arg2 ;
66575   Dali::Actor *argp2 ;
66576
66577   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66578   argp2 = (Dali::Actor *)jarg2;
66579   if (!argp2) {
66580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66581     return ;
66582   }
66583   arg2 = *argp2;
66584   {
66585     try {
66586       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
66587     } catch (std::out_of_range& e) {
66588       {
66589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66590       };
66591     } catch (std::exception& e) {
66592       {
66593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66594       };
66595     } catch (Dali::DaliException e) {
66596       {
66597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66598       };
66599     } catch (...) {
66600       {
66601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66602       };
66603     }
66604   }
66605
66606 }
66607
66608
66609 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
66610   unsigned int jresult ;
66611   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66612   bool result;
66613
66614   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66615   {
66616     try {
66617       result = (bool)(arg1)->OnKeyboardEnter();
66618     } catch (std::out_of_range& e) {
66619       {
66620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66621       };
66622     } catch (std::exception& e) {
66623       {
66624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66625       };
66626     } catch (Dali::DaliException e) {
66627       {
66628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66629       };
66630     } catch (...) {
66631       {
66632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66633       };
66634     }
66635   }
66636
66637   jresult = result;
66638   return jresult;
66639 }
66640
66641
66642 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
66643   unsigned int jresult ;
66644   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66645   bool result;
66646
66647   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66648   {
66649     try {
66650       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
66651     } catch (std::out_of_range& e) {
66652       {
66653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66654       };
66655     } catch (std::exception& e) {
66656       {
66657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66658       };
66659     } catch (Dali::DaliException e) {
66660       {
66661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66662       };
66663     } catch (...) {
66664       {
66665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66666       };
66667     }
66668   }
66669
66670   jresult = result;
66671   return jresult;
66672 }
66673
66674
66675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
66676   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66677   Dali::PinchGesture *arg2 = 0 ;
66678
66679   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66680   arg2 = (Dali::PinchGesture *)jarg2;
66681   if (!arg2) {
66682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66683     return ;
66684   }
66685   {
66686     try {
66687       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
66688     } catch (std::out_of_range& e) {
66689       {
66690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66691       };
66692     } catch (std::exception& e) {
66693       {
66694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66695       };
66696     } catch (Dali::DaliException e) {
66697       {
66698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66699       };
66700     } catch (...) {
66701       {
66702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66703       };
66704     }
66705   }
66706
66707 }
66708
66709
66710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66711   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66712   Dali::PinchGesture *arg2 = 0 ;
66713
66714   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66715   arg2 = (Dali::PinchGesture *)jarg2;
66716   if (!arg2) {
66717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66718     return ;
66719   }
66720   {
66721     try {
66722       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
66723     } catch (std::out_of_range& e) {
66724       {
66725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66726       };
66727     } catch (std::exception& e) {
66728       {
66729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66730       };
66731     } catch (Dali::DaliException e) {
66732       {
66733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66734       };
66735     } catch (...) {
66736       {
66737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66738       };
66739     }
66740   }
66741
66742 }
66743
66744
66745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
66746   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66747   Dali::PanGesture *arg2 = 0 ;
66748
66749   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66750   arg2 = (Dali::PanGesture *)jarg2;
66751   if (!arg2) {
66752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66753     return ;
66754   }
66755   {
66756     try {
66757       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
66758     } catch (std::out_of_range& e) {
66759       {
66760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66761       };
66762     } catch (std::exception& e) {
66763       {
66764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66765       };
66766     } catch (Dali::DaliException e) {
66767       {
66768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66769       };
66770     } catch (...) {
66771       {
66772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66773       };
66774     }
66775   }
66776
66777 }
66778
66779
66780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66781   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66782   Dali::PanGesture *arg2 = 0 ;
66783
66784   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66785   arg2 = (Dali::PanGesture *)jarg2;
66786   if (!arg2) {
66787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66788     return ;
66789   }
66790   {
66791     try {
66792       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
66793     } catch (std::out_of_range& e) {
66794       {
66795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66796       };
66797     } catch (std::exception& e) {
66798       {
66799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66800       };
66801     } catch (Dali::DaliException e) {
66802       {
66803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66804       };
66805     } catch (...) {
66806       {
66807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66808       };
66809     }
66810   }
66811
66812 }
66813
66814
66815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
66816   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66817   Dali::TapGesture *arg2 = 0 ;
66818
66819   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66820   arg2 = (Dali::TapGesture *)jarg2;
66821   if (!arg2) {
66822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66823     return ;
66824   }
66825   {
66826     try {
66827       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
66828     } catch (std::out_of_range& e) {
66829       {
66830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66831       };
66832     } catch (std::exception& e) {
66833       {
66834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66835       };
66836     } catch (Dali::DaliException e) {
66837       {
66838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66839       };
66840     } catch (...) {
66841       {
66842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66843       };
66844     }
66845   }
66846
66847 }
66848
66849
66850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66851   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66852   Dali::TapGesture *arg2 = 0 ;
66853
66854   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66855   arg2 = (Dali::TapGesture *)jarg2;
66856   if (!arg2) {
66857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66858     return ;
66859   }
66860   {
66861     try {
66862       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
66863     } catch (std::out_of_range& e) {
66864       {
66865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66866       };
66867     } catch (std::exception& e) {
66868       {
66869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66870       };
66871     } catch (Dali::DaliException e) {
66872       {
66873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66874       };
66875     } catch (...) {
66876       {
66877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66878       };
66879     }
66880   }
66881
66882 }
66883
66884
66885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
66886   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66887   Dali::LongPressGesture *arg2 = 0 ;
66888
66889   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66890   arg2 = (Dali::LongPressGesture *)jarg2;
66891   if (!arg2) {
66892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66893     return ;
66894   }
66895   {
66896     try {
66897       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
66898     } catch (std::out_of_range& e) {
66899       {
66900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66901       };
66902     } catch (std::exception& e) {
66903       {
66904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66905       };
66906     } catch (Dali::DaliException e) {
66907       {
66908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66909       };
66910     } catch (...) {
66911       {
66912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66913       };
66914     }
66915   }
66916
66917 }
66918
66919
66920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66921   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66922   Dali::LongPressGesture *arg2 = 0 ;
66923
66924   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66925   arg2 = (Dali::LongPressGesture *)jarg2;
66926   if (!arg2) {
66927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66928     return ;
66929   }
66930   {
66931     try {
66932       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
66933     } catch (std::out_of_range& e) {
66934       {
66935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66936       };
66937     } catch (std::exception& e) {
66938       {
66939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66940       };
66941     } catch (Dali::DaliException e) {
66942       {
66943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66944       };
66945     } catch (...) {
66946       {
66947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66948       };
66949     }
66950   }
66951
66952 }
66953
66954
66955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
66956   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66957   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66958   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66959
66960   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66961   arg2 = (Dali::SlotObserver *)jarg2;
66962   arg3 = (Dali::CallbackBase *)jarg3;
66963   {
66964     try {
66965       (arg1)->SignalConnected(arg2,arg3);
66966     } catch (std::out_of_range& e) {
66967       {
66968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66969       };
66970     } catch (std::exception& e) {
66971       {
66972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66973       };
66974     } catch (Dali::DaliException e) {
66975       {
66976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66977       };
66978     } catch (...) {
66979       {
66980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66981       };
66982     }
66983   }
66984
66985 }
66986
66987
66988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
66989   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66990   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66991   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66992
66993   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66994   arg2 = (Dali::SlotObserver *)jarg2;
66995   arg3 = (Dali::CallbackBase *)jarg3;
66996   {
66997     try {
66998       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
66999     } catch (std::out_of_range& e) {
67000       {
67001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67002       };
67003     } catch (std::exception& e) {
67004       {
67005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67006       };
67007     } catch (Dali::DaliException e) {
67008       {
67009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67010       };
67011     } catch (...) {
67012       {
67013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67014       };
67015     }
67016   }
67017
67018 }
67019
67020
67021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
67022   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67023   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67024   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67025
67026   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67027   arg2 = (Dali::SlotObserver *)jarg2;
67028   arg3 = (Dali::CallbackBase *)jarg3;
67029   {
67030     try {
67031       (arg1)->SignalDisconnected(arg2,arg3);
67032     } catch (std::out_of_range& e) {
67033       {
67034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67035       };
67036     } catch (std::exception& e) {
67037       {
67038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67039       };
67040     } catch (Dali::DaliException e) {
67041       {
67042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67043       };
67044     } catch (...) {
67045       {
67046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67047       };
67048     }
67049   }
67050
67051 }
67052
67053
67054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
67055   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67056   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67057   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67058
67059   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67060   arg2 = (Dali::SlotObserver *)jarg2;
67061   arg3 = (Dali::CallbackBase *)jarg3;
67062   {
67063     try {
67064       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
67065     } catch (std::out_of_range& e) {
67066       {
67067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67068       };
67069     } catch (std::exception& e) {
67070       {
67071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67072       };
67073     } catch (Dali::DaliException e) {
67074       {
67075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67076       };
67077     } catch (...) {
67078       {
67079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67080       };
67081     }
67082   }
67083
67084 }
67085
67086
67087 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) {
67088   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
67089   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
67090   if (director) {
67091     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);
67092   }
67093 }
67094
67095
67096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
67097   void * jresult ;
67098   Dali::Toolkit::Control *arg1 = 0 ;
67099   Dali::Toolkit::Internal::Control *result = 0 ;
67100
67101   arg1 = (Dali::Toolkit::Control *)jarg1;
67102   if (!arg1) {
67103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67104     return 0;
67105   }
67106   {
67107     try {
67108       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
67109     } catch (std::out_of_range& e) {
67110       {
67111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67112       };
67113     } catch (std::exception& e) {
67114       {
67115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67116       };
67117     } catch (Dali::DaliException e) {
67118       {
67119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67120       };
67121     } catch (...) {
67122       {
67123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67124       };
67125     }
67126   }
67127
67128   jresult = (void *)result;
67129   return jresult;
67130 }
67131
67132
67133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
67134   int jresult ;
67135   int result;
67136
67137   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
67138   jresult = (int)result;
67139   return jresult;
67140 }
67141
67142
67143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
67144   int jresult ;
67145   int result;
67146
67147   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
67148   jresult = (int)result;
67149   return jresult;
67150 }
67151
67152
67153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
67154   int jresult ;
67155   int result;
67156
67157   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
67158   jresult = (int)result;
67159   return jresult;
67160 }
67161
67162
67163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
67164   int jresult ;
67165   int result;
67166
67167   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
67168   jresult = (int)result;
67169   return jresult;
67170 }
67171
67172
67173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
67174   int jresult ;
67175   int result;
67176
67177   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
67178   jresult = (int)result;
67179   return jresult;
67180 }
67181
67182 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
67183   int jresult ;
67184   int result;
67185
67186   result = (int)Dali::Toolkit::Control::Property::MARGIN;
67187   jresult = (int)result;
67188   return jresult;
67189 }
67190
67191
67192 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
67193   int jresult ;
67194   int result;
67195
67196   result = (int)Dali::Toolkit::Control::Property::PADDING;
67197   jresult = (int)result;
67198   return jresult;
67199 }
67200
67201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
67202   void * jresult ;
67203   Dali::Toolkit::Control::Property *result = 0 ;
67204
67205   {
67206     try {
67207       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
67208     } catch (std::out_of_range& e) {
67209       {
67210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67211       };
67212     } catch (std::exception& e) {
67213       {
67214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67215       };
67216     } catch (Dali::DaliException e) {
67217       {
67218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67219       };
67220     } catch (...) {
67221       {
67222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67223       };
67224     }
67225   }
67226
67227   jresult = (void *)result;
67228   return jresult;
67229 }
67230
67231
67232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
67233   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
67234
67235   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
67236   {
67237     try {
67238       delete arg1;
67239     } catch (std::out_of_range& e) {
67240       {
67241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67242       };
67243     } catch (std::exception& e) {
67244       {
67245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67246       };
67247     } catch (Dali::DaliException e) {
67248       {
67249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67250       };
67251     } catch (...) {
67252       {
67253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67254       };
67255     }
67256   }
67257
67258 }
67259
67260
67261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
67262   void * jresult ;
67263   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
67264
67265   {
67266     try {
67267       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
67268     } catch (std::out_of_range& e) {
67269       {
67270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67271       };
67272     } catch (std::exception& e) {
67273       {
67274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67275       };
67276     } catch (Dali::DaliException e) {
67277       {
67278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67279       };
67280     } catch (...) {
67281       {
67282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67283       };
67284     }
67285   }
67286
67287   jresult = (void *)result;
67288   return jresult;
67289 }
67290
67291
67292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
67293   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
67294
67295   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
67296   {
67297     try {
67298       delete arg1;
67299     } catch (std::out_of_range& e) {
67300       {
67301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67302       };
67303     } catch (std::exception& e) {
67304       {
67305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67306       };
67307     } catch (Dali::DaliException e) {
67308       {
67309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67310       };
67311     } catch (...) {
67312       {
67313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67314       };
67315     }
67316   }
67317
67318 }
67319
67320
67321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
67322   void * jresult ;
67323   Dali::Toolkit::Control result;
67324
67325   {
67326     try {
67327       result = Dali::Toolkit::Control::New();
67328     } catch (std::out_of_range& e) {
67329       {
67330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67331       };
67332     } catch (std::exception& e) {
67333       {
67334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67335       };
67336     } catch (Dali::DaliException e) {
67337       {
67338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67339       };
67340     } catch (...) {
67341       {
67342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67343       };
67344     }
67345   }
67346
67347   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67348   return jresult;
67349 }
67350
67351
67352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
67353   void * jresult ;
67354   Dali::Toolkit::Control *result = 0 ;
67355
67356   {
67357     try {
67358       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
67359     } catch (std::out_of_range& e) {
67360       {
67361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67362       };
67363     } catch (std::exception& e) {
67364       {
67365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67366       };
67367     } catch (Dali::DaliException e) {
67368       {
67369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67370       };
67371     } catch (...) {
67372       {
67373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67374       };
67375     }
67376   }
67377
67378   jresult = (void *)result;
67379   return jresult;
67380 }
67381
67382
67383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
67384   void * jresult ;
67385   Dali::Toolkit::Control *arg1 = 0 ;
67386   Dali::Toolkit::Control *result = 0 ;
67387
67388   arg1 = (Dali::Toolkit::Control *)jarg1;
67389   if (!arg1) {
67390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67391     return 0;
67392   }
67393   {
67394     try {
67395       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
67396     } catch (std::out_of_range& e) {
67397       {
67398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67399       };
67400     } catch (std::exception& e) {
67401       {
67402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67403       };
67404     } catch (Dali::DaliException e) {
67405       {
67406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67407       };
67408     } catch (...) {
67409       {
67410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67411       };
67412     }
67413   }
67414
67415   jresult = (void *)result;
67416   return jresult;
67417 }
67418
67419
67420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
67421   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67422
67423   arg1 = (Dali::Toolkit::Control *)jarg1;
67424   {
67425     try {
67426       delete arg1;
67427     } catch (std::out_of_range& e) {
67428       {
67429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67430       };
67431     } catch (std::exception& e) {
67432       {
67433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67434       };
67435     } catch (Dali::DaliException e) {
67436       {
67437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67438       };
67439     } catch (...) {
67440       {
67441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67442       };
67443     }
67444   }
67445
67446 }
67447
67448
67449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
67450   void * jresult ;
67451   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67452   Dali::Toolkit::Control *arg2 = 0 ;
67453   Dali::Toolkit::Control *result = 0 ;
67454
67455   arg1 = (Dali::Toolkit::Control *)jarg1;
67456   arg2 = (Dali::Toolkit::Control *)jarg2;
67457   if (!arg2) {
67458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67459     return 0;
67460   }
67461   {
67462     try {
67463       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
67464     } catch (std::out_of_range& e) {
67465       {
67466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67467       };
67468     } catch (std::exception& e) {
67469       {
67470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67471       };
67472     } catch (Dali::DaliException e) {
67473       {
67474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67475       };
67476     } catch (...) {
67477       {
67478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67479       };
67480     }
67481   }
67482
67483   jresult = (void *)result;
67484   return jresult;
67485 }
67486
67487
67488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
67489   void * jresult ;
67490   Dali::BaseHandle arg1 ;
67491   Dali::BaseHandle *argp1 ;
67492   Dali::Toolkit::Control result;
67493
67494   argp1 = (Dali::BaseHandle *)jarg1;
67495   if (!argp1) {
67496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67497     return 0;
67498   }
67499   arg1 = *argp1;
67500   {
67501     try {
67502       result = Dali::Toolkit::Control::DownCast(arg1);
67503     } catch (std::out_of_range& e) {
67504       {
67505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67506       };
67507     } catch (std::exception& e) {
67508       {
67509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67510       };
67511     } catch (Dali::DaliException e) {
67512       {
67513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67514       };
67515     } catch (...) {
67516       {
67517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67518       };
67519     }
67520   }
67521
67522   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67523   return jresult;
67524 }
67525
67526
67527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
67528   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67529
67530   arg1 = (Dali::Toolkit::Control *)jarg1;
67531   {
67532     try {
67533       (arg1)->SetKeyInputFocus();
67534     } catch (std::out_of_range& e) {
67535       {
67536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67537       };
67538     } catch (std::exception& e) {
67539       {
67540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67541       };
67542     } catch (Dali::DaliException e) {
67543       {
67544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67545       };
67546     } catch (...) {
67547       {
67548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67549       };
67550     }
67551   }
67552
67553 }
67554
67555
67556 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
67557   unsigned int jresult ;
67558   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67559   bool result;
67560
67561   arg1 = (Dali::Toolkit::Control *)jarg1;
67562   {
67563     try {
67564       result = (bool)(arg1)->HasKeyInputFocus();
67565     } catch (std::out_of_range& e) {
67566       {
67567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67568       };
67569     } catch (std::exception& e) {
67570       {
67571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67572       };
67573     } catch (Dali::DaliException e) {
67574       {
67575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67576       };
67577     } catch (...) {
67578       {
67579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67580       };
67581     }
67582   }
67583
67584   jresult = result;
67585   return jresult;
67586 }
67587
67588
67589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
67590   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67591
67592   arg1 = (Dali::Toolkit::Control *)jarg1;
67593   {
67594     try {
67595       (arg1)->ClearKeyInputFocus();
67596     } catch (std::out_of_range& e) {
67597       {
67598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67599       };
67600     } catch (std::exception& e) {
67601       {
67602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67603       };
67604     } catch (Dali::DaliException e) {
67605       {
67606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67607       };
67608     } catch (...) {
67609       {
67610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67611       };
67612     }
67613   }
67614
67615 }
67616
67617
67618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
67619   void * jresult ;
67620   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67621   Dali::PinchGestureDetector result;
67622
67623   arg1 = (Dali::Toolkit::Control *)jarg1;
67624   {
67625     try {
67626       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
67627     } catch (std::out_of_range& e) {
67628       {
67629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67630       };
67631     } catch (std::exception& e) {
67632       {
67633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67634       };
67635     } catch (Dali::DaliException e) {
67636       {
67637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67638       };
67639     } catch (...) {
67640       {
67641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67642       };
67643     }
67644   }
67645
67646   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
67647   return jresult;
67648 }
67649
67650
67651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
67652   void * jresult ;
67653   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67654   Dali::PanGestureDetector result;
67655
67656   arg1 = (Dali::Toolkit::Control *)jarg1;
67657   {
67658     try {
67659       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
67660     } catch (std::out_of_range& e) {
67661       {
67662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67663       };
67664     } catch (std::exception& e) {
67665       {
67666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67667       };
67668     } catch (Dali::DaliException e) {
67669       {
67670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67671       };
67672     } catch (...) {
67673       {
67674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67675       };
67676     }
67677   }
67678
67679   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
67680   return jresult;
67681 }
67682
67683
67684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
67685   void * jresult ;
67686   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67687   Dali::TapGestureDetector result;
67688
67689   arg1 = (Dali::Toolkit::Control *)jarg1;
67690   {
67691     try {
67692       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
67693     } catch (std::out_of_range& e) {
67694       {
67695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67696       };
67697     } catch (std::exception& e) {
67698       {
67699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67700       };
67701     } catch (Dali::DaliException e) {
67702       {
67703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67704       };
67705     } catch (...) {
67706       {
67707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67708       };
67709     }
67710   }
67711
67712   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
67713   return jresult;
67714 }
67715
67716
67717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
67718   void * jresult ;
67719   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67720   Dali::LongPressGestureDetector result;
67721
67722   arg1 = (Dali::Toolkit::Control *)jarg1;
67723   {
67724     try {
67725       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
67726     } catch (std::out_of_range& e) {
67727       {
67728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67729       };
67730     } catch (std::exception& e) {
67731       {
67732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67733       };
67734     } catch (Dali::DaliException e) {
67735       {
67736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67737       };
67738     } catch (...) {
67739       {
67740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67741       };
67742     }
67743   }
67744
67745   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
67746   return jresult;
67747 }
67748
67749
67750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
67751   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67752   std::string *arg2 = 0 ;
67753
67754   arg1 = (Dali::Toolkit::Control *)jarg1;
67755   if (!jarg2) {
67756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67757     return ;
67758   }
67759   std::string arg2_str(jarg2);
67760   arg2 = &arg2_str;
67761   {
67762     try {
67763       (arg1)->SetStyleName((std::string const &)*arg2);
67764     } catch (std::out_of_range& e) {
67765       {
67766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67767       };
67768     } catch (std::exception& e) {
67769       {
67770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67771       };
67772     } catch (Dali::DaliException e) {
67773       {
67774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67775       };
67776     } catch (...) {
67777       {
67778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67779       };
67780     }
67781   }
67782
67783
67784   //argout typemap for const std::string&
67785
67786 }
67787
67788
67789 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
67790   char * jresult ;
67791   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67792   std::string *result = 0 ;
67793
67794   arg1 = (Dali::Toolkit::Control *)jarg1;
67795   {
67796     try {
67797       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
67798     } catch (std::out_of_range& e) {
67799       {
67800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67801       };
67802     } catch (std::exception& e) {
67803       {
67804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67805       };
67806     } catch (Dali::DaliException e) {
67807       {
67808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67809       };
67810     } catch (...) {
67811       {
67812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67813       };
67814     }
67815   }
67816
67817   jresult = SWIG_csharp_string_callback(result->c_str());
67818   return jresult;
67819 }
67820
67821
67822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
67823   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67824   Dali::Vector4 *arg2 = 0 ;
67825
67826   arg1 = (Dali::Toolkit::Control *)jarg1;
67827   arg2 = (Dali::Vector4 *)jarg2;
67828   if (!arg2) {
67829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
67830     return ;
67831   }
67832   {
67833     try {
67834       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
67835     } catch (std::out_of_range& e) {
67836       {
67837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67838       };
67839     } catch (std::exception& e) {
67840       {
67841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67842       };
67843     } catch (Dali::DaliException e) {
67844       {
67845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67846       };
67847     } catch (...) {
67848       {
67849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67850       };
67851     }
67852   }
67853
67854 }
67855
67856
67857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
67858   void * jresult ;
67859   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67860   Dali::Vector4 result;
67861
67862   arg1 = (Dali::Toolkit::Control *)jarg1;
67863   {
67864     try {
67865       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
67866     } catch (std::out_of_range& e) {
67867       {
67868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67869       };
67870     } catch (std::exception& e) {
67871       {
67872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67873       };
67874     } catch (Dali::DaliException e) {
67875       {
67876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67877       };
67878     } catch (...) {
67879       {
67880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67881       };
67882     }
67883   }
67884
67885   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
67886   return jresult;
67887 }
67888
67889
67890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
67891   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67892   Dali::Image arg2 ;
67893   Dali::Image *argp2 ;
67894
67895   arg1 = (Dali::Toolkit::Control *)jarg1;
67896   argp2 = (Dali::Image *)jarg2;
67897   if (!argp2) {
67898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
67899     return ;
67900   }
67901   arg2 = *argp2;
67902   {
67903     try {
67904       (arg1)->SetBackgroundImage(arg2);
67905     } catch (std::out_of_range& e) {
67906       {
67907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67908       };
67909     } catch (std::exception& e) {
67910       {
67911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67912       };
67913     } catch (Dali::DaliException e) {
67914       {
67915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67916       };
67917     } catch (...) {
67918       {
67919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67920       };
67921     }
67922   }
67923
67924 }
67925
67926
67927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
67928   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67929
67930   arg1 = (Dali::Toolkit::Control *)jarg1;
67931   {
67932     try {
67933       (arg1)->ClearBackground();
67934     } catch (std::out_of_range& e) {
67935       {
67936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67937       };
67938     } catch (std::exception& e) {
67939       {
67940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67941       };
67942     } catch (Dali::DaliException e) {
67943       {
67944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67945       };
67946     } catch (...) {
67947       {
67948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67949       };
67950     }
67951   }
67952
67953 }
67954
67955
67956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
67957   void * jresult ;
67958   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67959   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
67960
67961   arg1 = (Dali::Toolkit::Control *)jarg1;
67962   {
67963     try {
67964       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
67965     } catch (std::out_of_range& e) {
67966       {
67967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67968       };
67969     } catch (std::exception& e) {
67970       {
67971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67972       };
67973     } catch (Dali::DaliException e) {
67974       {
67975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67976       };
67977     } catch (...) {
67978       {
67979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67980       };
67981     }
67982   }
67983
67984   jresult = (void *)result;
67985   return jresult;
67986 }
67987
67988
67989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
67990   void * jresult ;
67991   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67992   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
67993
67994   arg1 = (Dali::Toolkit::Control *)jarg1;
67995   {
67996     try {
67997       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
67998     } catch (std::out_of_range& e) {
67999       {
68000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68001       };
68002     } catch (std::exception& e) {
68003       {
68004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68005       };
68006     } catch (Dali::DaliException e) {
68007       {
68008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68009       };
68010     } catch (...) {
68011       {
68012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68013       };
68014     }
68015   }
68016
68017   jresult = (void *)result;
68018   return jresult;
68019 }
68020
68021
68022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
68023   void * jresult ;
68024   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68025   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
68026
68027   arg1 = (Dali::Toolkit::Control *)jarg1;
68028   {
68029     try {
68030       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
68031     } catch (std::out_of_range& e) {
68032       {
68033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68034       };
68035     } catch (std::exception& e) {
68036       {
68037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68038       };
68039     } catch (Dali::DaliException e) {
68040       {
68041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68042       };
68043     } catch (...) {
68044       {
68045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68046       };
68047     }
68048   }
68049
68050   jresult = (void *)result;
68051   return jresult;
68052 }
68053
68054
68055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
68056   void * jresult ;
68057   Dali::Toolkit::Internal::Control *arg1 = 0 ;
68058   Dali::Toolkit::Control *result = 0 ;
68059
68060   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
68061   if (!arg1) {
68062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68063     return 0;
68064   }
68065   {
68066     try {
68067       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
68068     } catch (std::out_of_range& e) {
68069       {
68070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68071       };
68072     } catch (std::exception& e) {
68073       {
68074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68075       };
68076     } catch (Dali::DaliException e) {
68077       {
68078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68079       };
68080     } catch (...) {
68081       {
68082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68083       };
68084     }
68085   }
68086
68087   jresult = (void *)result;
68088   return jresult;
68089 }
68090
68091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
68092 {
68093   int jresult;
68094   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68095   arg1 = (Dali::Toolkit::Control *)jarg1;
68096
68097   if (!arg1) {
68098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68099     return 0;
68100   }
68101
68102   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
68103
68104   Dali::Property::Index arg2 = 0 ;
68105   arg2 = (Dali::Property::Index)jarg2;
68106
68107   Toolkit::Visual::ResourceStatus result;
68108   {
68109     try {
68110       result = DevelControl::GetVisualResourceStatus(controlImpl, arg2);
68111     } catch (std::out_of_range& e) {
68112       {
68113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68114       };
68115     } catch (std::exception& e) {
68116       {
68117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68118       };
68119     } catch (...) {
68120       {
68121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68122       };
68123     }
68124   }
68125   jresult = (int)(result);
68126   return jresult;
68127 }
68128
68129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
68130 {
68131   void * jresult;
68132   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68133   arg1 = (Dali::Toolkit::Control *)jarg1;
68134
68135   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
68136
68137   Dali::Toolkit::TransitionData *arg2 = 0 ;
68138   Dali::Animation result;
68139
68140   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
68141   if (!arg2) {
68142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
68143     return 0;
68144   }
68145   {
68146     try {
68147       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
68148     } catch (std::out_of_range& e) {
68149       {
68150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68151       };
68152     } catch (std::exception& e) {
68153       {
68154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68155       };
68156     } catch (Dali::DaliException e) {
68157       {
68158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68159       };
68160     } catch (...) {
68161       {
68162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68163       };
68164     }
68165   }
68166
68167   jresult = new Dali::Animation((const Dali::Animation &)result);
68168   return jresult;
68169 }
68170
68171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
68172   void * jresult ;
68173   Dali::Toolkit::Control *arg1 = 0 ;
68174   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
68175
68176   arg1 = (Dali::Toolkit::Control *)jarg1;
68177   if (!arg1) {
68178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68179     return 0;
68180   }
68181   {
68182     try {
68183       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
68184     } catch (std::out_of_range& e) {
68185       {
68186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68187       };
68188     } catch (std::exception& e) {
68189       {
68190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68191       };
68192     } catch (Dali::DaliException e) {
68193       {
68194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68195       };
68196     } catch (...) {
68197       {
68198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68199       };
68200     }
68201   }
68202
68203   jresult = (void *)result;
68204   return jresult;
68205 }
68206
68207
68208 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
68209   unsigned int jresult ;
68210   Dali::Toolkit::Control *arg1 = 0 ;
68211   bool result;
68212
68213   arg1 = (Dali::Toolkit::Control *)jarg1;
68214   if (!arg1) {
68215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
68216     return 0;
68217   }
68218   {
68219     try {
68220       result = (bool)arg1->IsResourceReady();
68221     } catch (std::out_of_range& e) {
68222       {
68223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68224       };
68225     } catch (std::exception& e) {
68226       {
68227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68228       };
68229     } catch (Dali::DaliException e) {
68230       {
68231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68232       };
68233     } catch (...) {
68234       {
68235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68236       };
68237     }
68238   }
68239
68240   jresult = result;
68241   return jresult;
68242 }
68243
68244
68245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
68246   void * jresult ;
68247   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
68248
68249   {
68250     try {
68251       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
68252     } catch (std::out_of_range& e) {
68253       {
68254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68255       };
68256     } catch (std::exception& e) {
68257       {
68258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68259       };
68260     } catch (Dali::DaliException e) {
68261       {
68262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68263       };
68264     } catch (...) {
68265       {
68266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68267       };
68268     }
68269   }
68270
68271   jresult = (void *)result;
68272   return jresult;
68273 }
68274
68275
68276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
68277   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68278
68279   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68280   {
68281     try {
68282       delete arg1;
68283     } catch (std::out_of_range& e) {
68284       {
68285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68286       };
68287     } catch (std::exception& e) {
68288       {
68289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68290       };
68291     } catch (Dali::DaliException e) {
68292       {
68293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68294       };
68295     } catch (...) {
68296       {
68297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68298       };
68299     }
68300   }
68301
68302 }
68303
68304
68305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
68306   void * jresult ;
68307   Dali::Toolkit::KeyInputFocusManager result;
68308
68309   {
68310     try {
68311       result = Dali::Toolkit::KeyInputFocusManager::Get();
68312     } catch (std::out_of_range& e) {
68313       {
68314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68315       };
68316     } catch (std::exception& e) {
68317       {
68318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68319       };
68320     } catch (Dali::DaliException e) {
68321       {
68322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68323       };
68324     } catch (...) {
68325       {
68326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68327       };
68328     }
68329   }
68330
68331   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
68332   return jresult;
68333 }
68334
68335
68336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
68337   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68338   Dali::Toolkit::Control arg2 ;
68339   Dali::Toolkit::Control *argp2 ;
68340
68341   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68342   argp2 = (Dali::Toolkit::Control *)jarg2;
68343   if (!argp2) {
68344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68345     return ;
68346   }
68347   arg2 = *argp2;
68348   {
68349     try {
68350       (arg1)->SetFocus(arg2);
68351     } catch (std::out_of_range& e) {
68352       {
68353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68354       };
68355     } catch (std::exception& e) {
68356       {
68357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68358       };
68359     } catch (Dali::DaliException e) {
68360       {
68361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68362       };
68363     } catch (...) {
68364       {
68365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68366       };
68367     }
68368   }
68369
68370 }
68371
68372
68373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
68374   void * jresult ;
68375   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68376   Dali::Toolkit::Control result;
68377
68378   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68379   {
68380     try {
68381       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
68382     } catch (std::out_of_range& e) {
68383       {
68384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68385       };
68386     } catch (std::exception& e) {
68387       {
68388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68389       };
68390     } catch (Dali::DaliException e) {
68391       {
68392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68393       };
68394     } catch (...) {
68395       {
68396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68397       };
68398     }
68399   }
68400
68401   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
68402   return jresult;
68403 }
68404
68405
68406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
68407   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68408   Dali::Toolkit::Control arg2 ;
68409   Dali::Toolkit::Control *argp2 ;
68410
68411   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68412   argp2 = (Dali::Toolkit::Control *)jarg2;
68413   if (!argp2) {
68414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68415     return ;
68416   }
68417   arg2 = *argp2;
68418   {
68419     try {
68420       (arg1)->RemoveFocus(arg2);
68421     } catch (std::out_of_range& e) {
68422       {
68423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68424       };
68425     } catch (std::exception& e) {
68426       {
68427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68428       };
68429     } catch (Dali::DaliException e) {
68430       {
68431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68432       };
68433     } catch (...) {
68434       {
68435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68436       };
68437     }
68438   }
68439
68440 }
68441
68442
68443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
68444   void * jresult ;
68445   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68446   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
68447
68448   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68449   {
68450     try {
68451       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
68452     } catch (std::out_of_range& e) {
68453       {
68454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68455       };
68456     } catch (std::exception& e) {
68457       {
68458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68459       };
68460     } catch (Dali::DaliException e) {
68461       {
68462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68463       };
68464     } catch (...) {
68465       {
68466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68467       };
68468     }
68469   }
68470
68471   jresult = (void *)result;
68472   return jresult;
68473 }
68474
68475
68476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
68477   void * jresult ;
68478   Dali::Toolkit::Alignment::Padding *result = 0 ;
68479
68480   {
68481     try {
68482       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
68483     } catch (std::out_of_range& e) {
68484       {
68485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68486       };
68487     } catch (std::exception& e) {
68488       {
68489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68490       };
68491     } catch (Dali::DaliException e) {
68492       {
68493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68494       };
68495     } catch (...) {
68496       {
68497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68498       };
68499     }
68500   }
68501
68502   jresult = (void *)result;
68503   return jresult;
68504 }
68505
68506
68507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
68508   void * jresult ;
68509   float arg1 ;
68510   float arg2 ;
68511   float arg3 ;
68512   float arg4 ;
68513   Dali::Toolkit::Alignment::Padding *result = 0 ;
68514
68515   arg1 = (float)jarg1;
68516   arg2 = (float)jarg2;
68517   arg3 = (float)jarg3;
68518   arg4 = (float)jarg4;
68519   {
68520     try {
68521       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
68522     } catch (std::out_of_range& e) {
68523       {
68524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68525       };
68526     } catch (std::exception& e) {
68527       {
68528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68529       };
68530     } catch (Dali::DaliException e) {
68531       {
68532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68533       };
68534     } catch (...) {
68535       {
68536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68537       };
68538     }
68539   }
68540
68541   jresult = (void *)result;
68542   return jresult;
68543 }
68544
68545
68546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
68547   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68548   float arg2 ;
68549
68550   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68551   arg2 = (float)jarg2;
68552   if (arg1) (arg1)->left = arg2;
68553 }
68554
68555
68556 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
68557   float jresult ;
68558   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68559   float result;
68560
68561   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68562   result = (float) ((arg1)->left);
68563   jresult = result;
68564   return jresult;
68565 }
68566
68567
68568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
68569   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68570   float arg2 ;
68571
68572   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68573   arg2 = (float)jarg2;
68574   if (arg1) (arg1)->right = arg2;
68575 }
68576
68577
68578 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
68579   float jresult ;
68580   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68581   float result;
68582
68583   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68584   result = (float) ((arg1)->right);
68585   jresult = result;
68586   return jresult;
68587 }
68588
68589
68590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
68591   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68592   float arg2 ;
68593
68594   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68595   arg2 = (float)jarg2;
68596   if (arg1) (arg1)->top = arg2;
68597 }
68598
68599
68600 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
68601   float jresult ;
68602   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68603   float result;
68604
68605   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68606   result = (float) ((arg1)->top);
68607   jresult = result;
68608   return jresult;
68609 }
68610
68611
68612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
68613   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68614   float arg2 ;
68615
68616   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68617   arg2 = (float)jarg2;
68618   if (arg1) (arg1)->bottom = arg2;
68619 }
68620
68621
68622 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
68623   float jresult ;
68624   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68625   float result;
68626
68627   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68628   result = (float) ((arg1)->bottom);
68629   jresult = result;
68630   return jresult;
68631 }
68632
68633
68634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
68635   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68636
68637   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68638   {
68639     try {
68640       delete arg1;
68641     } catch (std::out_of_range& e) {
68642       {
68643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68644       };
68645     } catch (std::exception& e) {
68646       {
68647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68648       };
68649     } catch (Dali::DaliException e) {
68650       {
68651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68652       };
68653     } catch (...) {
68654       {
68655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68656       };
68657     }
68658   }
68659
68660 }
68661
68662
68663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
68664   void * jresult ;
68665   Dali::Toolkit::Alignment *result = 0 ;
68666
68667   {
68668     try {
68669       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
68670     } catch (std::out_of_range& e) {
68671       {
68672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68673       };
68674     } catch (std::exception& e) {
68675       {
68676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68677       };
68678     } catch (Dali::DaliException e) {
68679       {
68680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68681       };
68682     } catch (...) {
68683       {
68684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68685       };
68686     }
68687   }
68688
68689   jresult = (void *)result;
68690   return jresult;
68691 }
68692
68693
68694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
68695   void * jresult ;
68696   Dali::Toolkit::Alignment::Type arg1 ;
68697   Dali::Toolkit::Alignment::Type arg2 ;
68698   Dali::Toolkit::Alignment result;
68699
68700   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68701   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68702   {
68703     try {
68704       result = Dali::Toolkit::Alignment::New(arg1,arg2);
68705     } catch (std::out_of_range& e) {
68706       {
68707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68708       };
68709     } catch (std::exception& e) {
68710       {
68711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68712       };
68713     } catch (Dali::DaliException e) {
68714       {
68715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68716       };
68717     } catch (...) {
68718       {
68719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68720       };
68721     }
68722   }
68723
68724   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68725   return jresult;
68726 }
68727
68728
68729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
68730   void * jresult ;
68731   Dali::Toolkit::Alignment::Type arg1 ;
68732   Dali::Toolkit::Alignment result;
68733
68734   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68735   {
68736     try {
68737       result = Dali::Toolkit::Alignment::New(arg1);
68738     } catch (std::out_of_range& e) {
68739       {
68740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68741       };
68742     } catch (std::exception& e) {
68743       {
68744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68745       };
68746     } catch (Dali::DaliException e) {
68747       {
68748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68749       };
68750     } catch (...) {
68751       {
68752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68753       };
68754     }
68755   }
68756
68757   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68758   return jresult;
68759 }
68760
68761
68762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
68763   void * jresult ;
68764   Dali::Toolkit::Alignment result;
68765
68766   {
68767     try {
68768       result = Dali::Toolkit::Alignment::New();
68769     } catch (std::out_of_range& e) {
68770       {
68771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68772       };
68773     } catch (std::exception& e) {
68774       {
68775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68776       };
68777     } catch (Dali::DaliException e) {
68778       {
68779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68780       };
68781     } catch (...) {
68782       {
68783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68784       };
68785     }
68786   }
68787
68788   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68789   return jresult;
68790 }
68791
68792
68793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
68794   void * jresult ;
68795   Dali::Toolkit::Alignment *arg1 = 0 ;
68796   Dali::Toolkit::Alignment *result = 0 ;
68797
68798   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68799   if (!arg1) {
68800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
68801     return 0;
68802   }
68803   {
68804     try {
68805       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
68806     } catch (std::out_of_range& e) {
68807       {
68808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68809       };
68810     } catch (std::exception& e) {
68811       {
68812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68813       };
68814     } catch (Dali::DaliException e) {
68815       {
68816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68817       };
68818     } catch (...) {
68819       {
68820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68821       };
68822     }
68823   }
68824
68825   jresult = (void *)result;
68826   return jresult;
68827 }
68828
68829
68830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
68831   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68832
68833   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68834   {
68835     try {
68836       delete arg1;
68837     } catch (std::out_of_range& e) {
68838       {
68839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68840       };
68841     } catch (std::exception& e) {
68842       {
68843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68844       };
68845     } catch (Dali::DaliException e) {
68846       {
68847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68848       };
68849     } catch (...) {
68850       {
68851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68852       };
68853     }
68854   }
68855
68856 }
68857
68858
68859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
68860   void * jresult ;
68861   Dali::BaseHandle arg1 ;
68862   Dali::BaseHandle *argp1 ;
68863   Dali::Toolkit::Alignment result;
68864
68865   argp1 = (Dali::BaseHandle *)jarg1;
68866   if (!argp1) {
68867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68868     return 0;
68869   }
68870   arg1 = *argp1;
68871   {
68872     try {
68873       result = Dali::Toolkit::Alignment::DownCast(arg1);
68874     } catch (std::out_of_range& e) {
68875       {
68876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68877       };
68878     } catch (std::exception& e) {
68879       {
68880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68881       };
68882     } catch (Dali::DaliException e) {
68883       {
68884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68885       };
68886     } catch (...) {
68887       {
68888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68889       };
68890     }
68891   }
68892
68893   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68894   return jresult;
68895 }
68896
68897
68898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
68899   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68900   Dali::Toolkit::Alignment::Type arg2 ;
68901
68902   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68903   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68904   {
68905     try {
68906       (arg1)->SetAlignmentType(arg2);
68907     } catch (std::out_of_range& e) {
68908       {
68909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68910       };
68911     } catch (std::exception& e) {
68912       {
68913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68914       };
68915     } catch (Dali::DaliException e) {
68916       {
68917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68918       };
68919     } catch (...) {
68920       {
68921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68922       };
68923     }
68924   }
68925
68926 }
68927
68928
68929 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
68930   int jresult ;
68931   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68932   Dali::Toolkit::Alignment::Type result;
68933
68934   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68935   {
68936     try {
68937       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
68938     } catch (std::out_of_range& e) {
68939       {
68940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68941       };
68942     } catch (std::exception& e) {
68943       {
68944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68945       };
68946     } catch (Dali::DaliException e) {
68947       {
68948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68949       };
68950     } catch (...) {
68951       {
68952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68953       };
68954     }
68955   }
68956
68957   jresult = (int)result;
68958   return jresult;
68959 }
68960
68961
68962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
68963   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68964   Dali::Toolkit::Alignment::Scaling arg2 ;
68965
68966   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68967   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
68968   {
68969     try {
68970       (arg1)->SetScaling(arg2);
68971     } catch (std::out_of_range& e) {
68972       {
68973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68974       };
68975     } catch (std::exception& e) {
68976       {
68977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68978       };
68979     } catch (Dali::DaliException e) {
68980       {
68981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68982       };
68983     } catch (...) {
68984       {
68985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68986       };
68987     }
68988   }
68989
68990 }
68991
68992
68993 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
68994   int jresult ;
68995   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68996   Dali::Toolkit::Alignment::Scaling result;
68997
68998   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68999   {
69000     try {
69001       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
69002     } catch (std::out_of_range& e) {
69003       {
69004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69005       };
69006     } catch (std::exception& e) {
69007       {
69008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69009       };
69010     } catch (Dali::DaliException e) {
69011       {
69012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69013       };
69014     } catch (...) {
69015       {
69016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69017       };
69018     }
69019   }
69020
69021   jresult = (int)result;
69022   return jresult;
69023 }
69024
69025
69026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
69027   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69028   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
69029
69030   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69031   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
69032   if (!arg2) {
69033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
69034     return ;
69035   }
69036   {
69037     try {
69038       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
69039     } catch (std::out_of_range& e) {
69040       {
69041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69042       };
69043     } catch (std::exception& e) {
69044       {
69045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69046       };
69047     } catch (Dali::DaliException e) {
69048       {
69049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69050       };
69051     } catch (...) {
69052       {
69053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69054       };
69055     }
69056   }
69057
69058 }
69059
69060
69061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
69062   void * jresult ;
69063   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69064   Dali::Toolkit::Alignment::Padding *result = 0 ;
69065
69066   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69067   {
69068     try {
69069       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
69070     } catch (std::out_of_range& e) {
69071       {
69072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69073       };
69074     } catch (std::exception& e) {
69075       {
69076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69077       };
69078     } catch (Dali::DaliException e) {
69079       {
69080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69081       };
69082     } catch (...) {
69083       {
69084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69085       };
69086     }
69087   }
69088
69089   jresult = (void *)result;
69090   return jresult;
69091 }
69092
69093
69094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
69095   void * jresult ;
69096   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69097   Dali::Toolkit::Alignment *arg2 = 0 ;
69098   Dali::Toolkit::Alignment *result = 0 ;
69099
69100   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69101   arg2 = (Dali::Toolkit::Alignment *)jarg2;
69102   if (!arg2) {
69103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
69104     return 0;
69105   }
69106   {
69107     try {
69108       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
69109     } catch (std::out_of_range& e) {
69110       {
69111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69112       };
69113     } catch (std::exception& e) {
69114       {
69115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69116       };
69117     } catch (Dali::DaliException e) {
69118       {
69119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69120       };
69121     } catch (...) {
69122       {
69123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69124       };
69125     }
69126   }
69127
69128   jresult = (void *)result;
69129   return jresult;
69130 }
69131
69132
69133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
69134   int jresult ;
69135   int result;
69136
69137   result = (int)Dali::Toolkit::Button::Property::DISABLED;
69138   jresult = (int)result;
69139   return jresult;
69140 }
69141
69142
69143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
69144   int jresult ;
69145   int result;
69146
69147   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
69148   jresult = (int)result;
69149   return jresult;
69150 }
69151
69152
69153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
69154   int jresult ;
69155   int result;
69156
69157   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
69158   jresult = (int)result;
69159   return jresult;
69160 }
69161
69162
69163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
69164   int jresult ;
69165   int result;
69166
69167   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
69168   jresult = (int)result;
69169   return jresult;
69170 }
69171
69172
69173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
69174   int jresult ;
69175   int result;
69176
69177   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
69178   jresult = (int)result;
69179   return jresult;
69180 }
69181
69182
69183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
69184   int jresult ;
69185   int result;
69186
69187   result = (int)Dali::Toolkit::Button::Property::SELECTED;
69188   jresult = (int)result;
69189   return jresult;
69190 }
69191
69192
69193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
69194   int jresult ;
69195   int result;
69196
69197   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
69198   jresult = (int)result;
69199   return jresult;
69200 }
69201
69202
69203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
69204   int jresult ;
69205   int result;
69206
69207   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
69208   jresult = (int)result;
69209   return jresult;
69210 }
69211
69212
69213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
69214   int jresult ;
69215   int result;
69216
69217   result = (int)Dali::Toolkit::Button::Property::LABEL;
69218   jresult = (int)result;
69219   return jresult;
69220 }
69221
69222
69223 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
69224   int jresult ;
69225   int result;
69226
69227   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
69228   jresult = (int)result;
69229   return jresult;
69230 }
69231
69232
69233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
69234   void * jresult ;
69235   Dali::Toolkit::Button::Property *result = 0 ;
69236
69237   {
69238     try {
69239       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
69240     } catch (std::out_of_range& e) {
69241       {
69242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69243       };
69244     } catch (std::exception& e) {
69245       {
69246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69247       };
69248     } catch (Dali::DaliException e) {
69249       {
69250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69251       };
69252     } catch (...) {
69253       {
69254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69255       };
69256     }
69257   }
69258
69259   jresult = (void *)result;
69260   return jresult;
69261 }
69262
69263
69264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
69265   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
69266
69267   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
69268   {
69269     try {
69270       delete arg1;
69271     } catch (std::out_of_range& e) {
69272       {
69273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69274       };
69275     } catch (std::exception& e) {
69276       {
69277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69278       };
69279     } catch (Dali::DaliException e) {
69280       {
69281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69282       };
69283     } catch (...) {
69284       {
69285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69286       };
69287     }
69288   }
69289
69290 }
69291
69292
69293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
69294   void * jresult ;
69295   Dali::Toolkit::Button *result = 0 ;
69296
69297   {
69298     try {
69299       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
69300     } catch (std::out_of_range& e) {
69301       {
69302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69303       };
69304     } catch (std::exception& e) {
69305       {
69306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69307       };
69308     } catch (Dali::DaliException e) {
69309       {
69310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69311       };
69312     } catch (...) {
69313       {
69314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69315       };
69316     }
69317   }
69318
69319   jresult = (void *)result;
69320   return jresult;
69321 }
69322
69323
69324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
69325   void * jresult ;
69326   Dali::Toolkit::Button *arg1 = 0 ;
69327   Dali::Toolkit::Button *result = 0 ;
69328
69329   arg1 = (Dali::Toolkit::Button *)jarg1;
69330   if (!arg1) {
69331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69332     return 0;
69333   }
69334   {
69335     try {
69336       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
69337     } catch (std::out_of_range& e) {
69338       {
69339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69340       };
69341     } catch (std::exception& e) {
69342       {
69343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69344       };
69345     } catch (Dali::DaliException e) {
69346       {
69347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69348       };
69349     } catch (...) {
69350       {
69351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69352       };
69353     }
69354   }
69355
69356   jresult = (void *)result;
69357   return jresult;
69358 }
69359
69360
69361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
69362   void * jresult ;
69363   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69364   Dali::Toolkit::Button *arg2 = 0 ;
69365   Dali::Toolkit::Button *result = 0 ;
69366
69367   arg1 = (Dali::Toolkit::Button *)jarg1;
69368   arg2 = (Dali::Toolkit::Button *)jarg2;
69369   if (!arg2) {
69370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69371     return 0;
69372   }
69373   {
69374     try {
69375       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
69376     } catch (std::out_of_range& e) {
69377       {
69378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69379       };
69380     } catch (std::exception& e) {
69381       {
69382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69383       };
69384     } catch (Dali::DaliException e) {
69385       {
69386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69387       };
69388     } catch (...) {
69389       {
69390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69391       };
69392     }
69393   }
69394
69395   jresult = (void *)result;
69396   return jresult;
69397 }
69398
69399
69400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
69401   void * jresult ;
69402   Dali::BaseHandle arg1 ;
69403   Dali::BaseHandle *argp1 ;
69404   Dali::Toolkit::Button result;
69405
69406   argp1 = (Dali::BaseHandle *)jarg1;
69407   if (!argp1) {
69408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69409     return 0;
69410   }
69411   arg1 = *argp1;
69412   {
69413     try {
69414       result = Dali::Toolkit::Button::DownCast(arg1);
69415     } catch (std::out_of_range& e) {
69416       {
69417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69418       };
69419     } catch (std::exception& e) {
69420       {
69421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69422       };
69423     } catch (Dali::DaliException e) {
69424       {
69425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69426       };
69427     } catch (...) {
69428       {
69429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69430       };
69431     }
69432   }
69433
69434   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
69435   return jresult;
69436 }
69437
69438
69439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
69440   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69441
69442   arg1 = (Dali::Toolkit::Button *)jarg1;
69443   {
69444     try {
69445       delete arg1;
69446     } catch (std::out_of_range& e) {
69447       {
69448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69449       };
69450     } catch (std::exception& e) {
69451       {
69452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69453       };
69454     } catch (Dali::DaliException e) {
69455       {
69456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69457       };
69458     } catch (...) {
69459       {
69460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69461       };
69462     }
69463   }
69464
69465 }
69466
69467
69468 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
69469   unsigned int jresult ;
69470   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69471   bool result;
69472
69473   arg1 = (Dali::Toolkit::Button *)jarg1;
69474   {
69475     try {
69476       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
69477     } catch (std::out_of_range& e) {
69478       {
69479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69480       };
69481     } catch (std::exception& e) {
69482       {
69483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69484       };
69485     } catch (Dali::DaliException e) {
69486       {
69487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69488       };
69489     } catch (...) {
69490       {
69491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69492       };
69493     }
69494   }
69495
69496   jresult = result;
69497   return jresult;
69498 }
69499
69500
69501 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
69502   unsigned int jresult ;
69503   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69504   bool result;
69505
69506   arg1 = (Dali::Toolkit::Button *)jarg1;
69507   {
69508     try {
69509       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
69510     } catch (std::out_of_range& e) {
69511       {
69512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69513       };
69514     } catch (std::exception& e) {
69515       {
69516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69517       };
69518     } catch (Dali::DaliException e) {
69519       {
69520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69521       };
69522     } catch (...) {
69523       {
69524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69525       };
69526     }
69527   }
69528
69529   jresult = result;
69530   return jresult;
69531 }
69532
69533
69534 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
69535   float jresult ;
69536   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69537   float result;
69538
69539   arg1 = (Dali::Toolkit::Button *)jarg1;
69540   {
69541     try {
69542       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
69543     } catch (std::out_of_range& e) {
69544       {
69545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69546       };
69547     } catch (std::exception& e) {
69548       {
69549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69550       };
69551     } catch (Dali::DaliException e) {
69552       {
69553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69554       };
69555     } catch (...) {
69556       {
69557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69558       };
69559     }
69560   }
69561
69562   jresult = result;
69563   return jresult;
69564 }
69565
69566
69567 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
69568   float jresult ;
69569   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69570   float result;
69571
69572   arg1 = (Dali::Toolkit::Button *)jarg1;
69573   {
69574     try {
69575       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
69576     } catch (std::out_of_range& e) {
69577       {
69578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69579       };
69580     } catch (std::exception& e) {
69581       {
69582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69583       };
69584     } catch (Dali::DaliException e) {
69585       {
69586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69587       };
69588     } catch (...) {
69589       {
69590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69591       };
69592     }
69593   }
69594
69595   jresult = result;
69596   return jresult;
69597 }
69598
69599
69600 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
69601   unsigned int jresult ;
69602   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69603   bool result;
69604
69605   arg1 = (Dali::Toolkit::Button *)jarg1;
69606   {
69607     try {
69608       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
69609     } catch (std::out_of_range& e) {
69610       {
69611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69612       };
69613     } catch (std::exception& e) {
69614       {
69615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69616       };
69617     } catch (Dali::DaliException e) {
69618       {
69619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69620       };
69621     } catch (...) {
69622       {
69623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69624       };
69625     }
69626   }
69627
69628   jresult = result;
69629   return jresult;
69630 }
69631
69632
69633 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
69634   unsigned int jresult ;
69635   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69636   bool result;
69637
69638   arg1 = (Dali::Toolkit::Button *)jarg1;
69639   {
69640     try {
69641       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
69642     } catch (std::out_of_range& e) {
69643       {
69644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69645       };
69646     } catch (std::exception& e) {
69647       {
69648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69649       };
69650     } catch (Dali::DaliException e) {
69651       {
69652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69653       };
69654     } catch (...) {
69655       {
69656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69657       };
69658     }
69659   }
69660
69661   jresult = result;
69662   return jresult;
69663 }
69664
69665
69666 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
69667   float jresult ;
69668   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69669   float result;
69670
69671   arg1 = (Dali::Toolkit::Button *)jarg1;
69672   {
69673     try {
69674       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
69675     } catch (std::out_of_range& e) {
69676       {
69677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69678       };
69679     } catch (std::exception& e) {
69680       {
69681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69682       };
69683     } catch (Dali::DaliException e) {
69684       {
69685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69686       };
69687     } catch (...) {
69688       {
69689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69690       };
69691     }
69692   }
69693
69694   jresult = result;
69695   return jresult;
69696 }
69697
69698
69699 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
69700   char * jresult ;
69701   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69702   std::string result;
69703
69704   arg1 = (Dali::Toolkit::Button *)jarg1;
69705   {
69706     try {
69707       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
69708     } catch (std::out_of_range& e) {
69709       {
69710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69711       };
69712     } catch (std::exception& e) {
69713       {
69714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69715       };
69716     } catch (Dali::DaliException e) {
69717       {
69718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69719       };
69720     } catch (...) {
69721       {
69722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69723       };
69724     }
69725   }
69726
69727   jresult = SWIG_csharp_string_callback((&result)->c_str());
69728   return jresult;
69729 }
69730
69731
69732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
69733   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69734   Dali::Actor arg2 ;
69735   Dali::Actor *argp2 ;
69736
69737   arg1 = (Dali::Toolkit::Button *)jarg1;
69738   argp2 = (Dali::Actor *)jarg2;
69739   if (!argp2) {
69740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
69741     return ;
69742   }
69743   arg2 = *argp2;
69744   {
69745     try {
69746       (arg1)->SetLabel(arg2);
69747     } catch (std::out_of_range& e) {
69748       {
69749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69750       };
69751     } catch (std::exception& e) {
69752       {
69753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69754       };
69755     } catch (Dali::DaliException e) {
69756       {
69757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69758       };
69759     } catch (...) {
69760       {
69761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69762       };
69763     }
69764   }
69765
69766 }
69767
69768
69769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
69770   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69771   Dali::Image arg2 ;
69772   Dali::Image *argp2 ;
69773
69774   arg1 = (Dali::Toolkit::Button *)jarg1;
69775   argp2 = (Dali::Image *)jarg2;
69776   if (!argp2) {
69777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
69778     return ;
69779   }
69780   arg2 = *argp2;
69781   {
69782     try {
69783       (arg1)->SetButtonImage(arg2);
69784     } catch (std::out_of_range& e) {
69785       {
69786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69787       };
69788     } catch (std::exception& e) {
69789       {
69790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69791       };
69792     } catch (Dali::DaliException e) {
69793       {
69794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69795       };
69796     } catch (...) {
69797       {
69798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69799       };
69800     }
69801   }
69802
69803 }
69804
69805
69806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
69807   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69808   Dali::Image arg2 ;
69809   Dali::Image *argp2 ;
69810
69811   arg1 = (Dali::Toolkit::Button *)jarg1;
69812   argp2 = (Dali::Image *)jarg2;
69813   if (!argp2) {
69814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
69815     return ;
69816   }
69817   arg2 = *argp2;
69818   {
69819     try {
69820       (arg1)->SetSelectedImage(arg2);
69821     } catch (std::out_of_range& e) {
69822       {
69823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69824       };
69825     } catch (std::exception& e) {
69826       {
69827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69828       };
69829     } catch (Dali::DaliException e) {
69830       {
69831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69832       };
69833     } catch (...) {
69834       {
69835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69836       };
69837     }
69838   }
69839
69840 }
69841
69842
69843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
69844   void * jresult ;
69845   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69846   Dali::Actor result;
69847
69848   arg1 = (Dali::Toolkit::Button *)jarg1;
69849   {
69850     try {
69851       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
69852     } catch (std::out_of_range& e) {
69853       {
69854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69855       };
69856     } catch (std::exception& e) {
69857       {
69858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69859       };
69860     } catch (Dali::DaliException e) {
69861       {
69862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69863       };
69864     } catch (...) {
69865       {
69866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69867       };
69868     }
69869   }
69870
69871   jresult = new Dali::Actor((const Dali::Actor &)result);
69872   return jresult;
69873 }
69874
69875
69876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
69877   void * jresult ;
69878   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69879   Dali::Actor result;
69880
69881   arg1 = (Dali::Toolkit::Button *)jarg1;
69882   {
69883     try {
69884       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
69885     } catch (std::out_of_range& e) {
69886       {
69887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69888       };
69889     } catch (std::exception& e) {
69890       {
69891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69892       };
69893     } catch (Dali::DaliException e) {
69894       {
69895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69896       };
69897     } catch (...) {
69898       {
69899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69900       };
69901     }
69902   }
69903
69904   jresult = new Dali::Actor((const Dali::Actor &)result);
69905   return jresult;
69906 }
69907
69908
69909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
69910   void * jresult ;
69911   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69912   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69913
69914   arg1 = (Dali::Toolkit::Button *)jarg1;
69915   {
69916     try {
69917       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
69918     } catch (std::out_of_range& e) {
69919       {
69920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69921       };
69922     } catch (std::exception& e) {
69923       {
69924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69925       };
69926     } catch (Dali::DaliException e) {
69927       {
69928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69929       };
69930     } catch (...) {
69931       {
69932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69933       };
69934     }
69935   }
69936
69937   jresult = (void *)result;
69938   return jresult;
69939 }
69940
69941
69942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
69943   void * jresult ;
69944   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69945   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69946
69947   arg1 = (Dali::Toolkit::Button *)jarg1;
69948   {
69949     try {
69950       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
69951     } catch (std::out_of_range& e) {
69952       {
69953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69954       };
69955     } catch (std::exception& e) {
69956       {
69957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69958       };
69959     } catch (Dali::DaliException e) {
69960       {
69961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69962       };
69963     } catch (...) {
69964       {
69965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69966       };
69967     }
69968   }
69969
69970   jresult = (void *)result;
69971   return jresult;
69972 }
69973
69974
69975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
69976   void * jresult ;
69977   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69978   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69979
69980   arg1 = (Dali::Toolkit::Button *)jarg1;
69981   {
69982     try {
69983       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
69984     } catch (std::out_of_range& e) {
69985       {
69986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69987       };
69988     } catch (std::exception& e) {
69989       {
69990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69991       };
69992     } catch (Dali::DaliException e) {
69993       {
69994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69995       };
69996     } catch (...) {
69997       {
69998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69999       };
70000     }
70001   }
70002
70003   jresult = (void *)result;
70004   return jresult;
70005 }
70006
70007
70008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
70009   void * jresult ;
70010   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70011   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70012
70013   arg1 = (Dali::Toolkit::Button *)jarg1;
70014   {
70015     try {
70016       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
70017     } catch (std::out_of_range& e) {
70018       {
70019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70020       };
70021     } catch (std::exception& e) {
70022       {
70023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70024       };
70025     } catch (Dali::DaliException e) {
70026       {
70027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70028       };
70029     } catch (...) {
70030       {
70031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70032       };
70033     }
70034   }
70035
70036   jresult = (void *)result;
70037   return jresult;
70038 }
70039
70040
70041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
70042   void * jresult ;
70043   Dali::Toolkit::CheckBoxButton *result = 0 ;
70044
70045   {
70046     try {
70047       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
70048     } catch (std::out_of_range& e) {
70049       {
70050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70051       };
70052     } catch (std::exception& e) {
70053       {
70054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70055       };
70056     } catch (Dali::DaliException e) {
70057       {
70058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70059       };
70060     } catch (...) {
70061       {
70062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70063       };
70064     }
70065   }
70066
70067   jresult = (void *)result;
70068   return jresult;
70069 }
70070
70071
70072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
70073   void * jresult ;
70074   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
70075   Dali::Toolkit::CheckBoxButton *result = 0 ;
70076
70077   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70078   if (!arg1) {
70079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70080     return 0;
70081   }
70082   {
70083     try {
70084       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
70085     } catch (std::out_of_range& e) {
70086       {
70087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70088       };
70089     } catch (std::exception& e) {
70090       {
70091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70092       };
70093     } catch (Dali::DaliException e) {
70094       {
70095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70096       };
70097     } catch (...) {
70098       {
70099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70100       };
70101     }
70102   }
70103
70104   jresult = (void *)result;
70105   return jresult;
70106 }
70107
70108
70109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
70110   void * jresult ;
70111   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70112   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
70113   Dali::Toolkit::CheckBoxButton *result = 0 ;
70114
70115   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70116   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
70117   if (!arg2) {
70118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70119     return 0;
70120   }
70121   {
70122     try {
70123       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
70124     } catch (std::out_of_range& e) {
70125       {
70126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70127       };
70128     } catch (std::exception& e) {
70129       {
70130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70131       };
70132     } catch (Dali::DaliException e) {
70133       {
70134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70135       };
70136     } catch (...) {
70137       {
70138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70139       };
70140     }
70141   }
70142
70143   jresult = (void *)result;
70144   return jresult;
70145 }
70146
70147
70148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
70149   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70150
70151   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70152   {
70153     try {
70154       delete arg1;
70155     } catch (std::out_of_range& e) {
70156       {
70157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70158       };
70159     } catch (std::exception& e) {
70160       {
70161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70162       };
70163     } catch (Dali::DaliException e) {
70164       {
70165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70166       };
70167     } catch (...) {
70168       {
70169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70170       };
70171     }
70172   }
70173
70174 }
70175
70176
70177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
70178   void * jresult ;
70179   Dali::Toolkit::CheckBoxButton result;
70180
70181   {
70182     try {
70183       result = Dali::Toolkit::CheckBoxButton::New();
70184     } catch (std::out_of_range& e) {
70185       {
70186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70187       };
70188     } catch (std::exception& e) {
70189       {
70190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70191       };
70192     } catch (Dali::DaliException e) {
70193       {
70194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70195       };
70196     } catch (...) {
70197       {
70198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70199       };
70200     }
70201   }
70202
70203   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70204   return jresult;
70205 }
70206
70207
70208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
70209   void * jresult ;
70210   Dali::BaseHandle arg1 ;
70211   Dali::BaseHandle *argp1 ;
70212   Dali::Toolkit::CheckBoxButton result;
70213
70214   argp1 = (Dali::BaseHandle *)jarg1;
70215   if (!argp1) {
70216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70217     return 0;
70218   }
70219   arg1 = *argp1;
70220   {
70221     try {
70222       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
70223     } catch (std::out_of_range& e) {
70224       {
70225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70226       };
70227     } catch (std::exception& e) {
70228       {
70229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70230       };
70231     } catch (Dali::DaliException e) {
70232       {
70233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70234       };
70235     } catch (...) {
70236       {
70237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70238       };
70239     }
70240   }
70241
70242   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70243   return jresult;
70244 }
70245
70246
70247 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
70248   int jresult ;
70249   int result;
70250
70251   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
70252   jresult = (int)result;
70253   return jresult;
70254 }
70255
70256
70257 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
70258   int jresult ;
70259   int result;
70260
70261   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
70262   jresult = (int)result;
70263   return jresult;
70264 }
70265
70266
70267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
70268   int jresult ;
70269   int result;
70270
70271   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
70272   jresult = (int)result;
70273   return jresult;
70274 }
70275
70276
70277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
70278   int jresult ;
70279   int result;
70280
70281   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
70282   jresult = (int)result;
70283   return jresult;
70284 }
70285
70286
70287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
70288   int jresult ;
70289   int result;
70290
70291   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
70292   jresult = (int)result;
70293   return jresult;
70294 }
70295
70296
70297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
70298   void * jresult ;
70299   Dali::Toolkit::PushButton::Property *result = 0 ;
70300
70301   {
70302     try {
70303       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
70304     } catch (std::out_of_range& e) {
70305       {
70306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70307       };
70308     } catch (std::exception& e) {
70309       {
70310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70311       };
70312     } catch (Dali::DaliException e) {
70313       {
70314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70315       };
70316     } catch (...) {
70317       {
70318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70319       };
70320     }
70321   }
70322
70323   jresult = (void *)result;
70324   return jresult;
70325 }
70326
70327
70328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
70329   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
70330
70331   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
70332   {
70333     try {
70334       delete arg1;
70335     } catch (std::out_of_range& e) {
70336       {
70337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70338       };
70339     } catch (std::exception& e) {
70340       {
70341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70342       };
70343     } catch (Dali::DaliException e) {
70344       {
70345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70346       };
70347     } catch (...) {
70348       {
70349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70350       };
70351     }
70352   }
70353
70354 }
70355
70356
70357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
70358   void * jresult ;
70359   Dali::Toolkit::PushButton *result = 0 ;
70360
70361   {
70362     try {
70363       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
70364     } catch (std::out_of_range& e) {
70365       {
70366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70367       };
70368     } catch (std::exception& e) {
70369       {
70370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70371       };
70372     } catch (Dali::DaliException e) {
70373       {
70374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70375       };
70376     } catch (...) {
70377       {
70378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70379       };
70380     }
70381   }
70382
70383   jresult = (void *)result;
70384   return jresult;
70385 }
70386
70387
70388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
70389   void * jresult ;
70390   Dali::Toolkit::PushButton *arg1 = 0 ;
70391   Dali::Toolkit::PushButton *result = 0 ;
70392
70393   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70394   if (!arg1) {
70395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70396     return 0;
70397   }
70398   {
70399     try {
70400       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
70401     } catch (std::out_of_range& e) {
70402       {
70403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70404       };
70405     } catch (std::exception& e) {
70406       {
70407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70408       };
70409     } catch (Dali::DaliException e) {
70410       {
70411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70412       };
70413     } catch (...) {
70414       {
70415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70416       };
70417     }
70418   }
70419
70420   jresult = (void *)result;
70421   return jresult;
70422 }
70423
70424
70425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
70426   void * jresult ;
70427   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70428   Dali::Toolkit::PushButton *arg2 = 0 ;
70429   Dali::Toolkit::PushButton *result = 0 ;
70430
70431   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70432   arg2 = (Dali::Toolkit::PushButton *)jarg2;
70433   if (!arg2) {
70434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70435     return 0;
70436   }
70437   {
70438     try {
70439       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
70440     } catch (std::out_of_range& e) {
70441       {
70442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70443       };
70444     } catch (std::exception& e) {
70445       {
70446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70447       };
70448     } catch (Dali::DaliException e) {
70449       {
70450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70451       };
70452     } catch (...) {
70453       {
70454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70455       };
70456     }
70457   }
70458
70459   jresult = (void *)result;
70460   return jresult;
70461 }
70462
70463
70464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
70465   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70466
70467   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70468   {
70469     try {
70470       delete arg1;
70471     } catch (std::out_of_range& e) {
70472       {
70473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70474       };
70475     } catch (std::exception& e) {
70476       {
70477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70478       };
70479     } catch (Dali::DaliException e) {
70480       {
70481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70482       };
70483     } catch (...) {
70484       {
70485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70486       };
70487     }
70488   }
70489
70490 }
70491
70492
70493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
70494   void * jresult ;
70495   Dali::Toolkit::PushButton result;
70496
70497   {
70498     try {
70499       result = Dali::Toolkit::PushButton::New();
70500     } catch (std::out_of_range& e) {
70501       {
70502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70503       };
70504     } catch (std::exception& e) {
70505       {
70506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70507       };
70508     } catch (Dali::DaliException e) {
70509       {
70510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70511       };
70512     } catch (...) {
70513       {
70514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70515       };
70516     }
70517   }
70518
70519   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
70520   return jresult;
70521 }
70522
70523
70524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
70525   void * jresult ;
70526   Dali::BaseHandle arg1 ;
70527   Dali::BaseHandle *argp1 ;
70528   Dali::Toolkit::PushButton result;
70529
70530   argp1 = (Dali::BaseHandle *)jarg1;
70531   if (!argp1) {
70532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70533     return 0;
70534   }
70535   arg1 = *argp1;
70536   {
70537     try {
70538       result = Dali::Toolkit::PushButton::DownCast(arg1);
70539     } catch (std::out_of_range& e) {
70540       {
70541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70542       };
70543     } catch (std::exception& e) {
70544       {
70545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70546       };
70547     } catch (Dali::DaliException e) {
70548       {
70549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70550       };
70551     } catch (...) {
70552       {
70553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70554       };
70555     }
70556   }
70557
70558   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
70559   return jresult;
70560 }
70561
70562
70563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
70564   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70565   Dali::Image arg2 ;
70566   Dali::Image *argp2 ;
70567
70568   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70569   argp2 = (Dali::Image *)jarg2;
70570   if (!argp2) {
70571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70572     return ;
70573   }
70574   arg2 = *argp2;
70575   {
70576     try {
70577       (arg1)->SetButtonImage(arg2);
70578     } catch (std::out_of_range& e) {
70579       {
70580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70581       };
70582     } catch (std::exception& e) {
70583       {
70584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70585       };
70586     } catch (Dali::DaliException e) {
70587       {
70588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70589       };
70590     } catch (...) {
70591       {
70592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70593       };
70594     }
70595   }
70596
70597 }
70598
70599
70600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
70601   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70602   Dali::Actor arg2 ;
70603   Dali::Actor *argp2 ;
70604
70605   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70606   argp2 = (Dali::Actor *)jarg2;
70607   if (!argp2) {
70608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70609     return ;
70610   }
70611   arg2 = *argp2;
70612   {
70613     try {
70614       (arg1)->SetButtonImage(arg2);
70615     } catch (std::out_of_range& e) {
70616       {
70617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70618       };
70619     } catch (std::exception& e) {
70620       {
70621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70622       };
70623     } catch (Dali::DaliException e) {
70624       {
70625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70626       };
70627     } catch (...) {
70628       {
70629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70630       };
70631     }
70632   }
70633
70634 }
70635
70636
70637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
70638   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70639   Dali::Actor arg2 ;
70640   Dali::Actor *argp2 ;
70641
70642   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70643   argp2 = (Dali::Actor *)jarg2;
70644   if (!argp2) {
70645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70646     return ;
70647   }
70648   arg2 = *argp2;
70649   {
70650     try {
70651       (arg1)->SetBackgroundImage(arg2);
70652     } catch (std::out_of_range& e) {
70653       {
70654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70655       };
70656     } catch (std::exception& e) {
70657       {
70658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70659       };
70660     } catch (Dali::DaliException e) {
70661       {
70662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70663       };
70664     } catch (...) {
70665       {
70666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70667       };
70668     }
70669   }
70670
70671 }
70672
70673
70674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
70675   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70676   Dali::Image arg2 ;
70677   Dali::Image *argp2 ;
70678
70679   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70680   argp2 = (Dali::Image *)jarg2;
70681   if (!argp2) {
70682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70683     return ;
70684   }
70685   arg2 = *argp2;
70686   {
70687     try {
70688       (arg1)->SetSelectedImage(arg2);
70689     } catch (std::out_of_range& e) {
70690       {
70691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70692       };
70693     } catch (std::exception& e) {
70694       {
70695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70696       };
70697     } catch (Dali::DaliException e) {
70698       {
70699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70700       };
70701     } catch (...) {
70702       {
70703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70704       };
70705     }
70706   }
70707
70708 }
70709
70710
70711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
70712   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70713   Dali::Actor arg2 ;
70714   Dali::Actor *argp2 ;
70715
70716   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70717   argp2 = (Dali::Actor *)jarg2;
70718   if (!argp2) {
70719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70720     return ;
70721   }
70722   arg2 = *argp2;
70723   {
70724     try {
70725       (arg1)->SetSelectedImage(arg2);
70726     } catch (std::out_of_range& e) {
70727       {
70728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70729       };
70730     } catch (std::exception& e) {
70731       {
70732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70733       };
70734     } catch (Dali::DaliException e) {
70735       {
70736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70737       };
70738     } catch (...) {
70739       {
70740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70741       };
70742     }
70743   }
70744
70745 }
70746
70747
70748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
70749   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70750   Dali::Actor arg2 ;
70751   Dali::Actor *argp2 ;
70752
70753   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70754   argp2 = (Dali::Actor *)jarg2;
70755   if (!argp2) {
70756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70757     return ;
70758   }
70759   arg2 = *argp2;
70760   {
70761     try {
70762       (arg1)->SetSelectedBackgroundImage(arg2);
70763     } catch (std::out_of_range& e) {
70764       {
70765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70766       };
70767     } catch (std::exception& e) {
70768       {
70769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70770       };
70771     } catch (Dali::DaliException e) {
70772       {
70773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70774       };
70775     } catch (...) {
70776       {
70777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70778       };
70779     }
70780   }
70781
70782 }
70783
70784
70785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
70786   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70787   Dali::Actor arg2 ;
70788   Dali::Actor *argp2 ;
70789
70790   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70791   argp2 = (Dali::Actor *)jarg2;
70792   if (!argp2) {
70793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70794     return ;
70795   }
70796   arg2 = *argp2;
70797   {
70798     try {
70799       (arg1)->SetDisabledBackgroundImage(arg2);
70800     } catch (std::out_of_range& e) {
70801       {
70802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70803       };
70804     } catch (std::exception& e) {
70805       {
70806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70807       };
70808     } catch (Dali::DaliException e) {
70809       {
70810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70811       };
70812     } catch (...) {
70813       {
70814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70815       };
70816     }
70817   }
70818
70819 }
70820
70821
70822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
70823   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70824   Dali::Actor arg2 ;
70825   Dali::Actor *argp2 ;
70826
70827   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70828   argp2 = (Dali::Actor *)jarg2;
70829   if (!argp2) {
70830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70831     return ;
70832   }
70833   arg2 = *argp2;
70834   {
70835     try {
70836       (arg1)->SetDisabledImage(arg2);
70837     } catch (std::out_of_range& e) {
70838       {
70839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70840       };
70841     } catch (std::exception& e) {
70842       {
70843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70844       };
70845     } catch (Dali::DaliException e) {
70846       {
70847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70848       };
70849     } catch (...) {
70850       {
70851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70852       };
70853     }
70854   }
70855
70856 }
70857
70858
70859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
70860   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70861   Dali::Actor arg2 ;
70862   Dali::Actor *argp2 ;
70863
70864   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70865   argp2 = (Dali::Actor *)jarg2;
70866   if (!argp2) {
70867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70868     return ;
70869   }
70870   arg2 = *argp2;
70871   {
70872     try {
70873       (arg1)->SetDisabledSelectedImage(arg2);
70874     } catch (std::out_of_range& e) {
70875       {
70876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70877       };
70878     } catch (std::exception& e) {
70879       {
70880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70881       };
70882     } catch (Dali::DaliException e) {
70883       {
70884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70885       };
70886     } catch (...) {
70887       {
70888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70889       };
70890     }
70891   }
70892
70893 }
70894
70895
70896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
70897   void * jresult ;
70898   Dali::Toolkit::RadioButton *result = 0 ;
70899
70900   {
70901     try {
70902       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
70903     } catch (std::out_of_range& e) {
70904       {
70905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70906       };
70907     } catch (std::exception& e) {
70908       {
70909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70910       };
70911     } catch (Dali::DaliException e) {
70912       {
70913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70914       };
70915     } catch (...) {
70916       {
70917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70918       };
70919     }
70920   }
70921
70922   jresult = (void *)result;
70923   return jresult;
70924 }
70925
70926
70927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
70928   void * jresult ;
70929   Dali::Toolkit::RadioButton *arg1 = 0 ;
70930   Dali::Toolkit::RadioButton *result = 0 ;
70931
70932   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
70933   if (!arg1) {
70934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
70935     return 0;
70936   }
70937   {
70938     try {
70939       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
70940     } catch (std::out_of_range& e) {
70941       {
70942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70943       };
70944     } catch (std::exception& e) {
70945       {
70946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70947       };
70948     } catch (Dali::DaliException e) {
70949       {
70950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70951       };
70952     } catch (...) {
70953       {
70954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70955       };
70956     }
70957   }
70958
70959   jresult = (void *)result;
70960   return jresult;
70961 }
70962
70963
70964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
70965   void * jresult ;
70966   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
70967   Dali::Toolkit::RadioButton *arg2 = 0 ;
70968   Dali::Toolkit::RadioButton *result = 0 ;
70969
70970   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
70971   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
70972   if (!arg2) {
70973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
70974     return 0;
70975   }
70976   {
70977     try {
70978       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
70979     } catch (std::out_of_range& e) {
70980       {
70981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70982       };
70983     } catch (std::exception& e) {
70984       {
70985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70986       };
70987     } catch (Dali::DaliException e) {
70988       {
70989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70990       };
70991     } catch (...) {
70992       {
70993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70994       };
70995     }
70996   }
70997
70998   jresult = (void *)result;
70999   return jresult;
71000 }
71001
71002
71003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
71004   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
71005
71006   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71007   {
71008     try {
71009       delete arg1;
71010     } catch (std::out_of_range& e) {
71011       {
71012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71013       };
71014     } catch (std::exception& e) {
71015       {
71016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71017       };
71018     } catch (Dali::DaliException e) {
71019       {
71020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71021       };
71022     } catch (...) {
71023       {
71024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71025       };
71026     }
71027   }
71028
71029 }
71030
71031
71032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
71033   void * jresult ;
71034   Dali::Toolkit::RadioButton result;
71035
71036   {
71037     try {
71038       result = Dali::Toolkit::RadioButton::New();
71039     } catch (std::out_of_range& e) {
71040       {
71041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71042       };
71043     } catch (std::exception& e) {
71044       {
71045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71046       };
71047     } catch (Dali::DaliException e) {
71048       {
71049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71050       };
71051     } catch (...) {
71052       {
71053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71054       };
71055     }
71056   }
71057
71058   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71059   return jresult;
71060 }
71061
71062
71063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
71064   void * jresult ;
71065   std::string *arg1 = 0 ;
71066   Dali::Toolkit::RadioButton result;
71067
71068   if (!jarg1) {
71069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71070     return 0;
71071   }
71072   std::string arg1_str(jarg1);
71073   arg1 = &arg1_str;
71074   {
71075     try {
71076       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
71077     } catch (std::out_of_range& e) {
71078       {
71079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71080       };
71081     } catch (std::exception& e) {
71082       {
71083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71084       };
71085     } catch (Dali::DaliException e) {
71086       {
71087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71088       };
71089     } catch (...) {
71090       {
71091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71092       };
71093     }
71094   }
71095
71096   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71097
71098   //argout typemap for const std::string&
71099
71100   return jresult;
71101 }
71102
71103
71104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
71105   void * jresult ;
71106   Dali::BaseHandle arg1 ;
71107   Dali::BaseHandle *argp1 ;
71108   Dali::Toolkit::RadioButton result;
71109
71110   argp1 = (Dali::BaseHandle *)jarg1;
71111   if (!argp1) {
71112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71113     return 0;
71114   }
71115   arg1 = *argp1;
71116   {
71117     try {
71118       result = Dali::Toolkit::RadioButton::DownCast(arg1);
71119     } catch (std::out_of_range& e) {
71120       {
71121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71122       };
71123     } catch (std::exception& e) {
71124       {
71125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71126       };
71127     } catch (Dali::DaliException e) {
71128       {
71129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71130       };
71131     } catch (...) {
71132       {
71133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71134       };
71135     }
71136   }
71137
71138   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71139   return jresult;
71140 }
71141
71142
71143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
71144   int jresult ;
71145   int result;
71146
71147   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
71148   jresult = (int)result;
71149   return jresult;
71150 }
71151
71152
71153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
71154   int jresult ;
71155   int result;
71156
71157   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
71158   jresult = (int)result;
71159   return jresult;
71160 }
71161
71162
71163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
71164   int jresult ;
71165   int result;
71166
71167   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
71168   jresult = (int)result;
71169   return jresult;
71170 }
71171
71172
71173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
71174   int jresult ;
71175   int result;
71176
71177   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
71178   jresult = (int)result;
71179   return jresult;
71180 }
71181
71182
71183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
71184   int jresult ;
71185   int result;
71186
71187   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
71188   jresult = (int)result;
71189   return jresult;
71190 }
71191
71192
71193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
71194   int jresult ;
71195   int result;
71196
71197   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
71198   jresult = (int)result;
71199   return jresult;
71200 }
71201
71202
71203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
71204   void * jresult ;
71205   Dali::Toolkit::FlexContainer::Property *result = 0 ;
71206
71207   {
71208     try {
71209       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
71210     } catch (std::out_of_range& e) {
71211       {
71212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71213       };
71214     } catch (std::exception& e) {
71215       {
71216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71217       };
71218     } catch (Dali::DaliException e) {
71219       {
71220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71221       };
71222     } catch (...) {
71223       {
71224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71225       };
71226     }
71227   }
71228
71229   jresult = (void *)result;
71230   return jresult;
71231 }
71232
71233
71234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
71235   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
71236
71237   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
71238   {
71239     try {
71240       delete arg1;
71241     } catch (std::out_of_range& e) {
71242       {
71243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71244       };
71245     } catch (std::exception& e) {
71246       {
71247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71248       };
71249     } catch (Dali::DaliException e) {
71250       {
71251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71252       };
71253     } catch (...) {
71254       {
71255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71256       };
71257     }
71258   }
71259
71260 }
71261
71262
71263 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
71264   int jresult ;
71265   int result;
71266
71267   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
71268   jresult = (int)result;
71269   return jresult;
71270 }
71271
71272
71273 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
71274   int jresult ;
71275   int result;
71276
71277   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
71278   jresult = (int)result;
71279   return jresult;
71280 }
71281
71282
71283 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
71284   int jresult ;
71285   int result;
71286
71287   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
71288   jresult = (int)result;
71289   return jresult;
71290 }
71291
71292
71293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
71294   void * jresult ;
71295   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
71296
71297   {
71298     try {
71299       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
71300     } catch (std::out_of_range& e) {
71301       {
71302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71303       };
71304     } catch (std::exception& e) {
71305       {
71306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71307       };
71308     } catch (Dali::DaliException e) {
71309       {
71310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71311       };
71312     } catch (...) {
71313       {
71314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71315       };
71316     }
71317   }
71318
71319   jresult = (void *)result;
71320   return jresult;
71321 }
71322
71323
71324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
71325   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
71326
71327   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
71328   {
71329     try {
71330       delete arg1;
71331     } catch (std::out_of_range& e) {
71332       {
71333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71334       };
71335     } catch (std::exception& e) {
71336       {
71337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71338       };
71339     } catch (Dali::DaliException e) {
71340       {
71341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71342       };
71343     } catch (...) {
71344       {
71345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71346       };
71347     }
71348   }
71349
71350 }
71351
71352
71353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
71354   void * jresult ;
71355   Dali::Toolkit::FlexContainer *result = 0 ;
71356
71357   {
71358     try {
71359       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
71360     } catch (std::out_of_range& e) {
71361       {
71362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71363       };
71364     } catch (std::exception& e) {
71365       {
71366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71367       };
71368     } catch (Dali::DaliException e) {
71369       {
71370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71371       };
71372     } catch (...) {
71373       {
71374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71375       };
71376     }
71377   }
71378
71379   jresult = (void *)result;
71380   return jresult;
71381 }
71382
71383
71384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
71385   void * jresult ;
71386   Dali::Toolkit::FlexContainer *arg1 = 0 ;
71387   Dali::Toolkit::FlexContainer *result = 0 ;
71388
71389   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71390   if (!arg1) {
71391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71392     return 0;
71393   }
71394   {
71395     try {
71396       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
71397     } catch (std::out_of_range& e) {
71398       {
71399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71400       };
71401     } catch (std::exception& e) {
71402       {
71403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71404       };
71405     } catch (Dali::DaliException e) {
71406       {
71407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71408       };
71409     } catch (...) {
71410       {
71411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71412       };
71413     }
71414   }
71415
71416   jresult = (void *)result;
71417   return jresult;
71418 }
71419
71420
71421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
71422   void * jresult ;
71423   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71424   Dali::Toolkit::FlexContainer *arg2 = 0 ;
71425   Dali::Toolkit::FlexContainer *result = 0 ;
71426
71427   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71428   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
71429   if (!arg2) {
71430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71431     return 0;
71432   }
71433   {
71434     try {
71435       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
71436     } catch (std::out_of_range& e) {
71437       {
71438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71439       };
71440     } catch (std::exception& e) {
71441       {
71442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71443       };
71444     } catch (Dali::DaliException e) {
71445       {
71446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71447       };
71448     } catch (...) {
71449       {
71450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71451       };
71452     }
71453   }
71454
71455   jresult = (void *)result;
71456   return jresult;
71457 }
71458
71459
71460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
71461   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71462
71463   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71464   {
71465     try {
71466       delete arg1;
71467     } catch (std::out_of_range& e) {
71468       {
71469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71470       };
71471     } catch (std::exception& e) {
71472       {
71473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71474       };
71475     } catch (Dali::DaliException e) {
71476       {
71477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71478       };
71479     } catch (...) {
71480       {
71481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71482       };
71483     }
71484   }
71485
71486 }
71487
71488
71489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
71490   void * jresult ;
71491   Dali::Toolkit::FlexContainer result;
71492
71493   {
71494     try {
71495       result = Dali::Toolkit::FlexContainer::New();
71496     } catch (std::out_of_range& e) {
71497       {
71498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71499       };
71500     } catch (std::exception& e) {
71501       {
71502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71503       };
71504     } catch (Dali::DaliException e) {
71505       {
71506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71507       };
71508     } catch (...) {
71509       {
71510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71511       };
71512     }
71513   }
71514
71515   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
71516   return jresult;
71517 }
71518
71519
71520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
71521   void * jresult ;
71522   Dali::BaseHandle arg1 ;
71523   Dali::BaseHandle *argp1 ;
71524   Dali::Toolkit::FlexContainer result;
71525
71526   argp1 = (Dali::BaseHandle *)jarg1;
71527   if (!argp1) {
71528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71529     return 0;
71530   }
71531   arg1 = *argp1;
71532   {
71533     try {
71534       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
71535     } catch (std::out_of_range& e) {
71536       {
71537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71538       };
71539     } catch (std::exception& e) {
71540       {
71541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71542       };
71543     } catch (Dali::DaliException e) {
71544       {
71545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71546       };
71547     } catch (...) {
71548       {
71549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71550       };
71551     }
71552   }
71553
71554   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
71555   return jresult;
71556 }
71557
71558
71559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
71560   int jresult ;
71561   int result;
71562
71563   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
71564   jresult = (int)result;
71565   return jresult;
71566 }
71567
71568
71569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
71570   int jresult ;
71571   int result;
71572
71573   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
71574   jresult = (int)result;
71575   return jresult;
71576 }
71577
71578
71579 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
71580   int jresult ;
71581   int result;
71582
71583   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
71584   jresult = (int)result;
71585   return jresult;
71586 }
71587
71588
71589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
71590   int jresult ;
71591   int result;
71592
71593   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
71594   jresult = (int)result;
71595   return jresult;
71596 }
71597
71598
71599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
71600   void * jresult ;
71601   Dali::Toolkit::ImageView::Property *result = 0 ;
71602
71603   {
71604     try {
71605       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
71606     } catch (std::out_of_range& e) {
71607       {
71608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71609       };
71610     } catch (std::exception& e) {
71611       {
71612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71613       };
71614     } catch (Dali::DaliException e) {
71615       {
71616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71617       };
71618     } catch (...) {
71619       {
71620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71621       };
71622     }
71623   }
71624
71625   jresult = (void *)result;
71626   return jresult;
71627 }
71628
71629
71630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
71631   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
71632
71633   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
71634   {
71635     try {
71636       delete arg1;
71637     } catch (std::out_of_range& e) {
71638       {
71639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71640       };
71641     } catch (std::exception& e) {
71642       {
71643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71644       };
71645     } catch (Dali::DaliException e) {
71646       {
71647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71648       };
71649     } catch (...) {
71650       {
71651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71652       };
71653     }
71654   }
71655
71656 }
71657
71658
71659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
71660   void * jresult ;
71661   Dali::Toolkit::ImageView *result = 0 ;
71662
71663   {
71664     try {
71665       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
71666     } catch (std::out_of_range& e) {
71667       {
71668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71669       };
71670     } catch (std::exception& e) {
71671       {
71672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71673       };
71674     } catch (Dali::DaliException e) {
71675       {
71676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71677       };
71678     } catch (...) {
71679       {
71680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71681       };
71682     }
71683   }
71684
71685   jresult = (void *)result;
71686   return jresult;
71687 }
71688
71689
71690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
71691   void * jresult ;
71692   Dali::Toolkit::ImageView result;
71693
71694   {
71695     try {
71696       result = Dali::Toolkit::ImageView::New();
71697     } catch (std::out_of_range& e) {
71698       {
71699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71700       };
71701     } catch (std::exception& e) {
71702       {
71703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71704       };
71705     } catch (Dali::DaliException e) {
71706       {
71707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71708       };
71709     } catch (...) {
71710       {
71711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71712       };
71713     }
71714   }
71715
71716   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71717   return jresult;
71718 }
71719
71720
71721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
71722   void * jresult ;
71723   Dali::Image arg1 ;
71724   Dali::Image *argp1 ;
71725   Dali::Toolkit::ImageView result;
71726
71727   argp1 = (Dali::Image *)jarg1;
71728   if (!argp1) {
71729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71730     return 0;
71731   }
71732   arg1 = *argp1;
71733   {
71734     try {
71735       result = Dali::Toolkit::ImageView::New(arg1);
71736     } catch (std::out_of_range& e) {
71737       {
71738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71739       };
71740     } catch (std::exception& e) {
71741       {
71742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71743       };
71744     } catch (Dali::DaliException e) {
71745       {
71746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71747       };
71748     } catch (...) {
71749       {
71750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71751       };
71752     }
71753   }
71754
71755   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71756   return jresult;
71757 }
71758
71759
71760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
71761   void * jresult ;
71762   std::string *arg1 = 0 ;
71763   Dali::Toolkit::ImageView result;
71764
71765   if (!jarg1) {
71766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71767     return 0;
71768   }
71769   std::string arg1_str(jarg1);
71770   arg1 = &arg1_str;
71771   {
71772     try {
71773       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
71774     } catch (std::out_of_range& e) {
71775       {
71776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71777       };
71778     } catch (std::exception& e) {
71779       {
71780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71781       };
71782     } catch (Dali::DaliException e) {
71783       {
71784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71785       };
71786     } catch (...) {
71787       {
71788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71789       };
71790     }
71791   }
71792
71793   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71794
71795   //argout typemap for const std::string&
71796
71797   return jresult;
71798 }
71799
71800
71801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
71802   void * jresult ;
71803   std::string *arg1 = 0 ;
71804   Dali::ImageDimensions arg2 ;
71805   Dali::ImageDimensions *argp2 ;
71806   Dali::Toolkit::ImageView result;
71807
71808   if (!jarg1) {
71809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71810     return 0;
71811   }
71812   std::string arg1_str(jarg1);
71813   arg1 = &arg1_str;
71814   argp2 = (Dali::ImageDimensions *)jarg2;
71815   if (!argp2) {
71816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
71817     return 0;
71818   }
71819   arg2 = *argp2;
71820   {
71821     try {
71822       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
71823     } catch (std::out_of_range& e) {
71824       {
71825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71826       };
71827     } catch (std::exception& e) {
71828       {
71829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71830       };
71831     } catch (Dali::DaliException e) {
71832       {
71833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71834       };
71835     } catch (...) {
71836       {
71837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71838       };
71839     }
71840   }
71841
71842   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71843
71844   //argout typemap for const std::string&
71845
71846   return jresult;
71847 }
71848
71849
71850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
71851   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71852
71853   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71854   {
71855     try {
71856       delete arg1;
71857     } catch (std::out_of_range& e) {
71858       {
71859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71860       };
71861     } catch (std::exception& e) {
71862       {
71863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71864       };
71865     } catch (Dali::DaliException e) {
71866       {
71867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71868       };
71869     } catch (...) {
71870       {
71871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71872       };
71873     }
71874   }
71875
71876 }
71877
71878
71879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
71880   void * jresult ;
71881   Dali::Toolkit::ImageView *arg1 = 0 ;
71882   Dali::Toolkit::ImageView *result = 0 ;
71883
71884   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71885   if (!arg1) {
71886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
71887     return 0;
71888   }
71889   {
71890     try {
71891       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
71892     } catch (std::out_of_range& e) {
71893       {
71894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71895       };
71896     } catch (std::exception& e) {
71897       {
71898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71899       };
71900     } catch (Dali::DaliException e) {
71901       {
71902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71903       };
71904     } catch (...) {
71905       {
71906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71907       };
71908     }
71909   }
71910
71911   jresult = (void *)result;
71912   return jresult;
71913 }
71914
71915
71916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
71917   void * jresult ;
71918   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71919   Dali::Toolkit::ImageView *arg2 = 0 ;
71920   Dali::Toolkit::ImageView *result = 0 ;
71921
71922   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71923   arg2 = (Dali::Toolkit::ImageView *)jarg2;
71924   if (!arg2) {
71925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
71926     return 0;
71927   }
71928   {
71929     try {
71930       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
71931     } catch (std::out_of_range& e) {
71932       {
71933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71934       };
71935     } catch (std::exception& e) {
71936       {
71937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71938       };
71939     } catch (Dali::DaliException e) {
71940       {
71941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71942       };
71943     } catch (...) {
71944       {
71945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71946       };
71947     }
71948   }
71949
71950   jresult = (void *)result;
71951   return jresult;
71952 }
71953
71954
71955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
71956   void * jresult ;
71957   Dali::BaseHandle arg1 ;
71958   Dali::BaseHandle *argp1 ;
71959   Dali::Toolkit::ImageView result;
71960
71961   argp1 = (Dali::BaseHandle *)jarg1;
71962   if (!argp1) {
71963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71964     return 0;
71965   }
71966   arg1 = *argp1;
71967   {
71968     try {
71969       result = Dali::Toolkit::ImageView::DownCast(arg1);
71970     } catch (std::out_of_range& e) {
71971       {
71972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71973       };
71974     } catch (std::exception& e) {
71975       {
71976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71977       };
71978     } catch (Dali::DaliException e) {
71979       {
71980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71981       };
71982     } catch (...) {
71983       {
71984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71985       };
71986     }
71987   }
71988
71989   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71990   return jresult;
71991 }
71992
71993
71994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
71995   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71996   Dali::Image arg2 ;
71997   Dali::Image *argp2 ;
71998
71999   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72000   argp2 = (Dali::Image *)jarg2;
72001   if (!argp2) {
72002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
72003     return ;
72004   }
72005   arg2 = *argp2;
72006   {
72007     try {
72008       (arg1)->SetImage(arg2);
72009     } catch (std::out_of_range& e) {
72010       {
72011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72012       };
72013     } catch (std::exception& e) {
72014       {
72015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72016       };
72017     } catch (Dali::DaliException e) {
72018       {
72019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72020       };
72021     } catch (...) {
72022       {
72023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72024       };
72025     }
72026   }
72027
72028 }
72029
72030
72031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
72032   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72033   std::string *arg2 = 0 ;
72034
72035   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72036   if (!jarg2) {
72037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72038     return ;
72039   }
72040   std::string arg2_str(jarg2);
72041   arg2 = &arg2_str;
72042   {
72043     try {
72044       (arg1)->SetImage((std::string const &)*arg2);
72045     } catch (std::out_of_range& e) {
72046       {
72047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72048       };
72049     } catch (std::exception& e) {
72050       {
72051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72052       };
72053     } catch (Dali::DaliException e) {
72054       {
72055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72056       };
72057     } catch (...) {
72058       {
72059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72060       };
72061     }
72062   }
72063
72064
72065   //argout typemap for const std::string&
72066
72067 }
72068
72069
72070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
72071   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72072   std::string *arg2 = 0 ;
72073   Dali::ImageDimensions arg3 ;
72074   Dali::ImageDimensions *argp3 ;
72075
72076   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72077   if (!jarg2) {
72078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72079     return ;
72080   }
72081   std::string arg2_str(jarg2);
72082   arg2 = &arg2_str;
72083   argp3 = (Dali::ImageDimensions *)jarg3;
72084   if (!argp3) {
72085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
72086     return ;
72087   }
72088   arg3 = *argp3;
72089   {
72090     try {
72091       (arg1)->SetImage((std::string const &)*arg2,arg3);
72092     } catch (std::out_of_range& e) {
72093       {
72094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72095       };
72096     } catch (std::exception& e) {
72097       {
72098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72099       };
72100     } catch (Dali::DaliException e) {
72101       {
72102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72103       };
72104     } catch (...) {
72105       {
72106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72107       };
72108     }
72109   }
72110
72111
72112   //argout typemap for const std::string&
72113
72114 }
72115
72116
72117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
72118   void * jresult ;
72119   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72120   Dali::Image result;
72121
72122   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72123   {
72124     try {
72125       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
72126     } catch (std::out_of_range& e) {
72127       {
72128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72129       };
72130     } catch (std::exception& e) {
72131       {
72132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72133       };
72134     } catch (Dali::DaliException e) {
72135       {
72136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72137       };
72138     } catch (...) {
72139       {
72140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72141       };
72142     }
72143   }
72144
72145   jresult = new Dali::Image((const Dali::Image &)result);
72146   return jresult;
72147 }
72148
72149
72150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
72151   int jresult ;
72152   int result;
72153
72154   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
72155   jresult = (int)result;
72156   return jresult;
72157 }
72158
72159
72160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
72161   int jresult ;
72162   int result;
72163
72164   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
72165   jresult = (int)result;
72166   return jresult;
72167 }
72168
72169
72170 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
72171   int jresult ;
72172   int result;
72173
72174   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
72175   jresult = (int)result;
72176   return jresult;
72177 }
72178
72179
72180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
72181   int jresult ;
72182   int result;
72183
72184   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
72185   jresult = (int)result;
72186   return jresult;
72187 }
72188
72189
72190 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
72191   int jresult ;
72192   int result;
72193
72194   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
72195   jresult = (int)result;
72196   return jresult;
72197 }
72198
72199
72200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
72201   int jresult ;
72202   int result;
72203
72204   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
72205   jresult = (int)result;
72206   return jresult;
72207 }
72208
72209
72210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
72211   int jresult ;
72212   int result;
72213
72214   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
72215   jresult = (int)result;
72216   return jresult;
72217 }
72218
72219
72220 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
72221   int jresult ;
72222   int result;
72223
72224   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
72225   jresult = (int)result;
72226   return jresult;
72227 }
72228
72229
72230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
72231   void * jresult ;
72232   Dali::Toolkit::Model3dView::Property *result = 0 ;
72233
72234   {
72235     try {
72236       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
72237     } catch (std::out_of_range& e) {
72238       {
72239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72240       };
72241     } catch (std::exception& e) {
72242       {
72243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72244       };
72245     } catch (Dali::DaliException e) {
72246       {
72247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72248       };
72249     } catch (...) {
72250       {
72251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72252       };
72253     }
72254   }
72255
72256   jresult = (void *)result;
72257   return jresult;
72258 }
72259
72260
72261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
72262   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
72263
72264   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
72265   {
72266     try {
72267       delete arg1;
72268     } catch (std::out_of_range& e) {
72269       {
72270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72271       };
72272     } catch (std::exception& e) {
72273       {
72274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72275       };
72276     } catch (Dali::DaliException e) {
72277       {
72278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72279       };
72280     } catch (...) {
72281       {
72282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72283       };
72284     }
72285   }
72286
72287 }
72288
72289
72290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
72291   void * jresult ;
72292   Dali::Toolkit::Model3dView result;
72293
72294   {
72295     try {
72296       result = Dali::Toolkit::Model3dView::New();
72297     } catch (std::out_of_range& e) {
72298       {
72299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72300       };
72301     } catch (std::exception& e) {
72302       {
72303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72304       };
72305     } catch (Dali::DaliException e) {
72306       {
72307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72308       };
72309     } catch (...) {
72310       {
72311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72312       };
72313     }
72314   }
72315
72316   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72317   return jresult;
72318 }
72319
72320
72321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
72322   void * jresult ;
72323   std::string *arg1 = 0 ;
72324   std::string *arg2 = 0 ;
72325   std::string *arg3 = 0 ;
72326   Dali::Toolkit::Model3dView result;
72327
72328   if (!jarg1) {
72329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72330     return 0;
72331   }
72332   std::string arg1_str(jarg1);
72333   arg1 = &arg1_str;
72334   if (!jarg2) {
72335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72336     return 0;
72337   }
72338   std::string arg2_str(jarg2);
72339   arg2 = &arg2_str;
72340   if (!jarg3) {
72341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72342     return 0;
72343   }
72344   std::string arg3_str(jarg3);
72345   arg3 = &arg3_str;
72346   {
72347     try {
72348       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
72349     } catch (std::out_of_range& e) {
72350       {
72351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72352       };
72353     } catch (std::exception& e) {
72354       {
72355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72356       };
72357     } catch (Dali::DaliException e) {
72358       {
72359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72360       };
72361     } catch (...) {
72362       {
72363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72364       };
72365     }
72366   }
72367
72368   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72369
72370   //argout typemap for const std::string&
72371
72372
72373   //argout typemap for const std::string&
72374
72375
72376   //argout typemap for const std::string&
72377
72378   return jresult;
72379 }
72380
72381
72382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
72383   void * jresult ;
72384   Dali::Toolkit::Model3dView *result = 0 ;
72385
72386   {
72387     try {
72388       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
72389     } catch (std::out_of_range& e) {
72390       {
72391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72392       };
72393     } catch (std::exception& e) {
72394       {
72395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72396       };
72397     } catch (Dali::DaliException e) {
72398       {
72399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72400       };
72401     } catch (...) {
72402       {
72403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72404       };
72405     }
72406   }
72407
72408   jresult = (void *)result;
72409   return jresult;
72410 }
72411
72412
72413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
72414   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72415
72416   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72417   {
72418     try {
72419       delete arg1;
72420     } catch (std::out_of_range& e) {
72421       {
72422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72423       };
72424     } catch (std::exception& e) {
72425       {
72426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72427       };
72428     } catch (Dali::DaliException e) {
72429       {
72430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72431       };
72432     } catch (...) {
72433       {
72434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72435       };
72436     }
72437   }
72438
72439 }
72440
72441
72442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
72443   void * jresult ;
72444   Dali::Toolkit::Model3dView *arg1 = 0 ;
72445   Dali::Toolkit::Model3dView *result = 0 ;
72446
72447   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72448   if (!arg1) {
72449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
72450     return 0;
72451   }
72452   {
72453     try {
72454       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
72455     } catch (std::out_of_range& e) {
72456       {
72457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72458       };
72459     } catch (std::exception& e) {
72460       {
72461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72462       };
72463     } catch (Dali::DaliException e) {
72464       {
72465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72466       };
72467     } catch (...) {
72468       {
72469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72470       };
72471     }
72472   }
72473
72474   jresult = (void *)result;
72475   return jresult;
72476 }
72477
72478
72479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
72480   void * jresult ;
72481   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72482   Dali::Toolkit::Model3dView *arg2 = 0 ;
72483   Dali::Toolkit::Model3dView *result = 0 ;
72484
72485   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72486   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
72487   if (!arg2) {
72488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
72489     return 0;
72490   }
72491   {
72492     try {
72493       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
72494     } catch (std::out_of_range& e) {
72495       {
72496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72497       };
72498     } catch (std::exception& e) {
72499       {
72500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72501       };
72502     } catch (Dali::DaliException e) {
72503       {
72504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72505       };
72506     } catch (...) {
72507       {
72508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72509       };
72510     }
72511   }
72512
72513   jresult = (void *)result;
72514   return jresult;
72515 }
72516
72517
72518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
72519   void * jresult ;
72520   Dali::BaseHandle arg1 ;
72521   Dali::BaseHandle *argp1 ;
72522   Dali::Toolkit::Model3dView result;
72523
72524   argp1 = (Dali::BaseHandle *)jarg1;
72525   if (!argp1) {
72526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72527     return 0;
72528   }
72529   arg1 = *argp1;
72530   {
72531     try {
72532       result = Dali::Toolkit::Model3dView::DownCast(arg1);
72533     } catch (std::out_of_range& e) {
72534       {
72535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72536       };
72537     } catch (std::exception& e) {
72538       {
72539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72540       };
72541     } catch (Dali::DaliException e) {
72542       {
72543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72544       };
72545     } catch (...) {
72546       {
72547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72548       };
72549     }
72550   }
72551
72552   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72553   return jresult;
72554 }
72555
72556
72557 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
72558   int jresult ;
72559   int result;
72560
72561   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
72562   jresult = (int)result;
72563   return jresult;
72564 }
72565
72566
72567 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
72568   int jresult ;
72569   int result;
72570
72571   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
72572   jresult = (int)result;
72573   return jresult;
72574 }
72575
72576
72577 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
72578   int jresult ;
72579   int result;
72580
72581   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
72582   jresult = (int)result;
72583   return jresult;
72584 }
72585
72586
72587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
72588   int jresult ;
72589   int result;
72590
72591   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
72592   jresult = (int)result;
72593   return jresult;
72594 }
72595
72596
72597 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
72598   int jresult ;
72599   int result;
72600
72601   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
72602   jresult = (int)result;
72603   return jresult;
72604 }
72605
72606
72607 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
72608   int jresult ;
72609   int result;
72610
72611   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
72612   jresult = (int)result;
72613   return jresult;
72614 }
72615
72616
72617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
72618   int jresult ;
72619   int result;
72620
72621   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
72622   jresult = (int)result;
72623   return jresult;
72624 }
72625
72626
72627 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
72628   int jresult ;
72629   int result;
72630
72631   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
72632   jresult = (int)result;
72633   return jresult;
72634 }
72635
72636
72637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
72638   int jresult ;
72639   int result;
72640
72641   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
72642   jresult = (int)result;
72643   return jresult;
72644 }
72645
72646
72647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
72648   void * jresult ;
72649   Dali::Toolkit::ScrollBar::Property *result = 0 ;
72650
72651   {
72652     try {
72653       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
72654     } catch (std::out_of_range& e) {
72655       {
72656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72657       };
72658     } catch (std::exception& e) {
72659       {
72660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72661       };
72662     } catch (Dali::DaliException e) {
72663       {
72664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72665       };
72666     } catch (...) {
72667       {
72668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72669       };
72670     }
72671   }
72672
72673   jresult = (void *)result;
72674   return jresult;
72675 }
72676
72677
72678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
72679   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
72680
72681   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
72682   {
72683     try {
72684       delete arg1;
72685     } catch (std::out_of_range& e) {
72686       {
72687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72688       };
72689     } catch (std::exception& e) {
72690       {
72691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72692       };
72693     } catch (Dali::DaliException e) {
72694       {
72695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72696       };
72697     } catch (...) {
72698       {
72699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72700       };
72701     }
72702   }
72703
72704 }
72705
72706
72707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
72708   void * jresult ;
72709   Dali::Toolkit::ScrollBar *result = 0 ;
72710
72711   {
72712     try {
72713       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
72714     } catch (std::out_of_range& e) {
72715       {
72716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72717       };
72718     } catch (std::exception& e) {
72719       {
72720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72721       };
72722     } catch (Dali::DaliException e) {
72723       {
72724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72725       };
72726     } catch (...) {
72727       {
72728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72729       };
72730     }
72731   }
72732
72733   jresult = (void *)result;
72734   return jresult;
72735 }
72736
72737
72738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
72739   void * jresult ;
72740   Dali::Toolkit::ScrollBar *arg1 = 0 ;
72741   Dali::Toolkit::ScrollBar *result = 0 ;
72742
72743   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72744   if (!arg1) {
72745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
72746     return 0;
72747   }
72748   {
72749     try {
72750       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
72751     } catch (std::out_of_range& e) {
72752       {
72753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72754       };
72755     } catch (std::exception& e) {
72756       {
72757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72758       };
72759     } catch (Dali::DaliException e) {
72760       {
72761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72762       };
72763     } catch (...) {
72764       {
72765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72766       };
72767     }
72768   }
72769
72770   jresult = (void *)result;
72771   return jresult;
72772 }
72773
72774
72775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
72776   void * jresult ;
72777   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72778   Dali::Toolkit::ScrollBar *arg2 = 0 ;
72779   Dali::Toolkit::ScrollBar *result = 0 ;
72780
72781   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72782   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
72783   if (!arg2) {
72784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
72785     return 0;
72786   }
72787   {
72788     try {
72789       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
72790     } catch (std::out_of_range& e) {
72791       {
72792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72793       };
72794     } catch (std::exception& e) {
72795       {
72796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72797       };
72798     } catch (Dali::DaliException e) {
72799       {
72800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72801       };
72802     } catch (...) {
72803       {
72804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72805       };
72806     }
72807   }
72808
72809   jresult = (void *)result;
72810   return jresult;
72811 }
72812
72813
72814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
72815   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72816
72817   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72818   {
72819     try {
72820       delete arg1;
72821     } catch (std::out_of_range& e) {
72822       {
72823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72824       };
72825     } catch (std::exception& e) {
72826       {
72827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72828       };
72829     } catch (Dali::DaliException e) {
72830       {
72831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72832       };
72833     } catch (...) {
72834       {
72835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72836       };
72837     }
72838   }
72839
72840 }
72841
72842
72843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
72844   void * jresult ;
72845   Dali::Toolkit::ScrollBar::Direction arg1 ;
72846   Dali::Toolkit::ScrollBar result;
72847
72848   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
72849   {
72850     try {
72851       result = Dali::Toolkit::ScrollBar::New(arg1);
72852     } catch (std::out_of_range& e) {
72853       {
72854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72855       };
72856     } catch (std::exception& e) {
72857       {
72858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72859       };
72860     } catch (Dali::DaliException e) {
72861       {
72862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72863       };
72864     } catch (...) {
72865       {
72866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72867       };
72868     }
72869   }
72870
72871   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
72872   return jresult;
72873 }
72874
72875
72876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
72877   void * jresult ;
72878   Dali::Toolkit::ScrollBar result;
72879
72880   {
72881     try {
72882       result = Dali::Toolkit::ScrollBar::New();
72883     } catch (std::out_of_range& e) {
72884       {
72885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72886       };
72887     } catch (std::exception& e) {
72888       {
72889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72890       };
72891     } catch (Dali::DaliException e) {
72892       {
72893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72894       };
72895     } catch (...) {
72896       {
72897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72898       };
72899     }
72900   }
72901
72902   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
72903   return jresult;
72904 }
72905
72906
72907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
72908   void * jresult ;
72909   Dali::BaseHandle arg1 ;
72910   Dali::BaseHandle *argp1 ;
72911   Dali::Toolkit::ScrollBar result;
72912
72913   argp1 = (Dali::BaseHandle *)jarg1;
72914   if (!argp1) {
72915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72916     return 0;
72917   }
72918   arg1 = *argp1;
72919   {
72920     try {
72921       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
72922     } catch (std::out_of_range& e) {
72923       {
72924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72925       };
72926     } catch (std::exception& e) {
72927       {
72928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72929       };
72930     } catch (Dali::DaliException e) {
72931       {
72932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72933       };
72934     } catch (...) {
72935       {
72936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72937       };
72938     }
72939   }
72940
72941   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
72942   return jresult;
72943 }
72944
72945
72946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
72947   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72948   Dali::Handle arg2 ;
72949   Dali::Property::Index arg3 ;
72950   Dali::Property::Index arg4 ;
72951   Dali::Property::Index arg5 ;
72952   Dali::Property::Index arg6 ;
72953   Dali::Handle *argp2 ;
72954
72955   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72956   argp2 = (Dali::Handle *)jarg2;
72957   if (!argp2) {
72958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
72959     return ;
72960   }
72961   arg2 = *argp2;
72962   arg3 = (Dali::Property::Index)jarg3;
72963   arg4 = (Dali::Property::Index)jarg4;
72964   arg5 = (Dali::Property::Index)jarg5;
72965   arg6 = (Dali::Property::Index)jarg6;
72966   {
72967     try {
72968       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
72969     } catch (std::out_of_range& e) {
72970       {
72971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72972       };
72973     } catch (std::exception& e) {
72974       {
72975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72976       };
72977     } catch (Dali::DaliException e) {
72978       {
72979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72980       };
72981     } catch (...) {
72982       {
72983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72984       };
72985     }
72986   }
72987
72988 }
72989
72990
72991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
72992   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72993   Dali::Actor arg2 ;
72994   Dali::Actor *argp2 ;
72995
72996   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72997   argp2 = (Dali::Actor *)jarg2;
72998   if (!argp2) {
72999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73000     return ;
73001   }
73002   arg2 = *argp2;
73003   {
73004     try {
73005       (arg1)->SetScrollIndicator(arg2);
73006     } catch (std::out_of_range& e) {
73007       {
73008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73009       };
73010     } catch (std::exception& e) {
73011       {
73012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73013       };
73014     } catch (Dali::DaliException e) {
73015       {
73016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73017       };
73018     } catch (...) {
73019       {
73020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73021       };
73022     }
73023   }
73024
73025 }
73026
73027
73028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
73029   void * jresult ;
73030   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73031   Dali::Actor result;
73032
73033   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73034   {
73035     try {
73036       result = (arg1)->GetScrollIndicator();
73037     } catch (std::out_of_range& e) {
73038       {
73039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73040       };
73041     } catch (std::exception& e) {
73042       {
73043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73044       };
73045     } catch (Dali::DaliException e) {
73046       {
73047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73048       };
73049     } catch (...) {
73050       {
73051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73052       };
73053     }
73054   }
73055
73056   jresult = new Dali::Actor((const Dali::Actor &)result);
73057   return jresult;
73058 }
73059
73060
73061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
73062   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73063   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
73064
73065   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73066   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
73067   if (!arg2) {
73068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
73069     return ;
73070   }
73071   {
73072     try {
73073       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
73074     } catch (std::out_of_range& e) {
73075       {
73076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73077       };
73078     } catch (std::exception& e) {
73079       {
73080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73081       };
73082     } catch (Dali::DaliException e) {
73083       {
73084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73085       };
73086     } catch (...) {
73087       {
73088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73089       };
73090     }
73091   }
73092
73093 }
73094
73095
73096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
73097   void * jresult ;
73098   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73099
73100   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73101   {
73102     try {
73103       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()));
73104     } catch (std::out_of_range& e) {
73105       {
73106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73107       };
73108     } catch (std::exception& e) {
73109       {
73110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73111       };
73112     } catch (...) {
73113       {
73114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73115       };
73116     }
73117   }
73118   return jresult;
73119 }
73120
73121
73122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
73123   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73124   Dali::Toolkit::ScrollBar::Direction arg2 ;
73125
73126   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73127   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
73128   {
73129     try {
73130       (arg1)->SetScrollDirection(arg2);
73131     } catch (std::out_of_range& e) {
73132       {
73133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73134       };
73135     } catch (std::exception& e) {
73136       {
73137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73138       };
73139     } catch (Dali::DaliException e) {
73140       {
73141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73142       };
73143     } catch (...) {
73144       {
73145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73146       };
73147     }
73148   }
73149
73150 }
73151
73152
73153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
73154   int jresult ;
73155   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73156   Dali::Toolkit::ScrollBar::Direction result;
73157
73158   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73159   {
73160     try {
73161       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
73162     } catch (std::out_of_range& e) {
73163       {
73164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73165       };
73166     } catch (std::exception& e) {
73167       {
73168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73169       };
73170     } catch (Dali::DaliException e) {
73171       {
73172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73173       };
73174     } catch (...) {
73175       {
73176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73177       };
73178     }
73179   }
73180
73181   jresult = (int)result;
73182   return jresult;
73183 }
73184
73185
73186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
73187   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73188   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
73189
73190   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73191   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
73192   {
73193     try {
73194       (arg1)->SetIndicatorHeightPolicy(arg2);
73195     } catch (std::out_of_range& e) {
73196       {
73197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73198       };
73199     } catch (std::exception& e) {
73200       {
73201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73202       };
73203     } catch (Dali::DaliException e) {
73204       {
73205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73206       };
73207     } catch (...) {
73208       {
73209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73210       };
73211     }
73212   }
73213
73214 }
73215
73216
73217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
73218   int jresult ;
73219   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73220   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
73221
73222   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73223   {
73224     try {
73225       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
73226     } catch (std::out_of_range& e) {
73227       {
73228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73229       };
73230     } catch (std::exception& e) {
73231       {
73232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73233       };
73234     } catch (Dali::DaliException e) {
73235       {
73236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73237       };
73238     } catch (...) {
73239       {
73240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73241       };
73242     }
73243   }
73244
73245   jresult = (int)result;
73246   return jresult;
73247 }
73248
73249
73250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
73251   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73252   float arg2 ;
73253
73254   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73255   arg2 = (float)jarg2;
73256   {
73257     try {
73258       (arg1)->SetIndicatorFixedHeight(arg2);
73259     } catch (std::out_of_range& e) {
73260       {
73261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73262       };
73263     } catch (std::exception& e) {
73264       {
73265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73266       };
73267     } catch (Dali::DaliException e) {
73268       {
73269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73270       };
73271     } catch (...) {
73272       {
73273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73274       };
73275     }
73276   }
73277
73278 }
73279
73280
73281 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
73282   float jresult ;
73283   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73284   float result;
73285
73286   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73287   {
73288     try {
73289       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
73290     } catch (std::out_of_range& e) {
73291       {
73292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73293       };
73294     } catch (std::exception& e) {
73295       {
73296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73297       };
73298     } catch (Dali::DaliException e) {
73299       {
73300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73301       };
73302     } catch (...) {
73303       {
73304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73305       };
73306     }
73307   }
73308
73309   jresult = result;
73310   return jresult;
73311 }
73312
73313
73314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
73315   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73316   float arg2 ;
73317
73318   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73319   arg2 = (float)jarg2;
73320   {
73321     try {
73322       (arg1)->SetIndicatorShowDuration(arg2);
73323     } catch (std::out_of_range& e) {
73324       {
73325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73326       };
73327     } catch (std::exception& e) {
73328       {
73329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73330       };
73331     } catch (Dali::DaliException e) {
73332       {
73333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73334       };
73335     } catch (...) {
73336       {
73337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73338       };
73339     }
73340   }
73341
73342 }
73343
73344
73345 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
73346   float jresult ;
73347   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73348   float result;
73349
73350   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73351   {
73352     try {
73353       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
73354     } catch (std::out_of_range& e) {
73355       {
73356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73357       };
73358     } catch (std::exception& e) {
73359       {
73360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73361       };
73362     } catch (Dali::DaliException e) {
73363       {
73364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73365       };
73366     } catch (...) {
73367       {
73368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73369       };
73370     }
73371   }
73372
73373   jresult = result;
73374   return jresult;
73375 }
73376
73377
73378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
73379   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73380   float arg2 ;
73381
73382   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73383   arg2 = (float)jarg2;
73384   {
73385     try {
73386       (arg1)->SetIndicatorHideDuration(arg2);
73387     } catch (std::out_of_range& e) {
73388       {
73389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73390       };
73391     } catch (std::exception& e) {
73392       {
73393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73394       };
73395     } catch (Dali::DaliException e) {
73396       {
73397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73398       };
73399     } catch (...) {
73400       {
73401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73402       };
73403     }
73404   }
73405
73406 }
73407
73408
73409 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
73410   float jresult ;
73411   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73412   float result;
73413
73414   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73415   {
73416     try {
73417       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
73418     } catch (std::out_of_range& e) {
73419       {
73420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73421       };
73422     } catch (std::exception& e) {
73423       {
73424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73425       };
73426     } catch (Dali::DaliException e) {
73427       {
73428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73429       };
73430     } catch (...) {
73431       {
73432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73433       };
73434     }
73435   }
73436
73437   jresult = result;
73438   return jresult;
73439 }
73440
73441
73442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
73443   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73444
73445   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73446   {
73447     try {
73448       (arg1)->ShowIndicator();
73449     } catch (std::out_of_range& e) {
73450       {
73451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73452       };
73453     } catch (std::exception& e) {
73454       {
73455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73456       };
73457     } catch (Dali::DaliException e) {
73458       {
73459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73460       };
73461     } catch (...) {
73462       {
73463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73464       };
73465     }
73466   }
73467
73468 }
73469
73470
73471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
73472   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73473
73474   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73475   {
73476     try {
73477       (arg1)->HideIndicator();
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 void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
73501   void * jresult ;
73502   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73503   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
73504
73505   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73506   {
73507     try {
73508       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
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 = (void *)result;
73529   return jresult;
73530 }
73531
73532
73533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
73534   void * jresult ;
73535   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73536   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
73537
73538   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73539   {
73540     try {
73541       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
73542     } catch (std::out_of_range& e) {
73543       {
73544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73545       };
73546     } catch (std::exception& e) {
73547       {
73548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73549       };
73550     } catch (Dali::DaliException e) {
73551       {
73552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73553       };
73554     } catch (...) {
73555       {
73556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73557       };
73558     }
73559   }
73560
73561   jresult = (void *)result;
73562   return jresult;
73563 }
73564
73565
73566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
73567   int jresult ;
73568   int result;
73569
73570   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
73571   jresult = (int)result;
73572   return jresult;
73573 }
73574
73575
73576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
73577   int jresult ;
73578   int result;
73579
73580   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
73581   jresult = (int)result;
73582   return jresult;
73583 }
73584
73585
73586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
73587   int jresult ;
73588   int result;
73589
73590   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
73591   jresult = (int)result;
73592   return jresult;
73593 }
73594
73595
73596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
73597   int jresult ;
73598   int result;
73599
73600   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
73601   jresult = (int)result;
73602   return jresult;
73603 }
73604
73605
73606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
73607   int jresult ;
73608   int result;
73609
73610   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
73611   jresult = (int)result;
73612   return jresult;
73613 }
73614
73615
73616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
73617   int jresult ;
73618   int result;
73619
73620   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
73621   jresult = (int)result;
73622   return jresult;
73623 }
73624
73625
73626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
73627   int jresult ;
73628   int result;
73629
73630   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
73631   jresult = (int)result;
73632   return jresult;
73633 }
73634
73635
73636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
73637   int jresult ;
73638   int result;
73639
73640   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
73641   jresult = (int)result;
73642   return jresult;
73643 }
73644
73645
73646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
73647   int jresult ;
73648   int result;
73649
73650   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
73651   jresult = (int)result;
73652   return jresult;
73653 }
73654
73655
73656 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
73657   int jresult ;
73658   int result;
73659
73660   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
73661   jresult = (int)result;
73662   return jresult;
73663 }
73664
73665
73666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
73667   int jresult ;
73668   int result;
73669
73670   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
73671   jresult = (int)result;
73672   return jresult;
73673 }
73674
73675
73676 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
73677   int jresult ;
73678   int result;
73679
73680   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
73681   jresult = (int)result;
73682   return jresult;
73683 }
73684
73685
73686 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
73687   int jresult ;
73688   int result;
73689
73690   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
73691   jresult = (int)result;
73692   return jresult;
73693 }
73694
73695
73696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
73697   int jresult ;
73698   int result;
73699
73700   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
73701   jresult = (int)result;
73702   return jresult;
73703 }
73704
73705
73706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
73707   void * jresult ;
73708   Dali::Toolkit::Scrollable::Property *result = 0 ;
73709
73710   {
73711     try {
73712       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
73713     } catch (std::out_of_range& e) {
73714       {
73715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73716       };
73717     } catch (std::exception& e) {
73718       {
73719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73720       };
73721     } catch (Dali::DaliException e) {
73722       {
73723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73724       };
73725     } catch (...) {
73726       {
73727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73728       };
73729     }
73730   }
73731
73732   jresult = (void *)result;
73733   return jresult;
73734 }
73735
73736
73737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
73738   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
73739
73740   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
73741   {
73742     try {
73743       delete arg1;
73744     } catch (std::out_of_range& e) {
73745       {
73746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73747       };
73748     } catch (std::exception& e) {
73749       {
73750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73751       };
73752     } catch (Dali::DaliException e) {
73753       {
73754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73755       };
73756     } catch (...) {
73757       {
73758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73759       };
73760     }
73761   }
73762
73763 }
73764
73765
73766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
73767   void * jresult ;
73768   Dali::Toolkit::Scrollable *result = 0 ;
73769
73770   {
73771     try {
73772       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
73773     } catch (std::out_of_range& e) {
73774       {
73775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73776       };
73777     } catch (std::exception& e) {
73778       {
73779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73780       };
73781     } catch (Dali::DaliException e) {
73782       {
73783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73784       };
73785     } catch (...) {
73786       {
73787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73788       };
73789     }
73790   }
73791
73792   jresult = (void *)result;
73793   return jresult;
73794 }
73795
73796
73797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
73798   void * jresult ;
73799   Dali::Toolkit::Scrollable *arg1 = 0 ;
73800   Dali::Toolkit::Scrollable *result = 0 ;
73801
73802   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73803   if (!arg1) {
73804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
73805     return 0;
73806   }
73807   {
73808     try {
73809       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
73810     } catch (std::out_of_range& e) {
73811       {
73812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73813       };
73814     } catch (std::exception& e) {
73815       {
73816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73817       };
73818     } catch (Dali::DaliException e) {
73819       {
73820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73821       };
73822     } catch (...) {
73823       {
73824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73825       };
73826     }
73827   }
73828
73829   jresult = (void *)result;
73830   return jresult;
73831 }
73832
73833
73834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
73835   void * jresult ;
73836   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73837   Dali::Toolkit::Scrollable *arg2 = 0 ;
73838   Dali::Toolkit::Scrollable *result = 0 ;
73839
73840   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73841   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
73842   if (!arg2) {
73843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
73844     return 0;
73845   }
73846   {
73847     try {
73848       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
73849     } catch (std::out_of_range& e) {
73850       {
73851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73852       };
73853     } catch (std::exception& e) {
73854       {
73855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73856       };
73857     } catch (Dali::DaliException e) {
73858       {
73859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73860       };
73861     } catch (...) {
73862       {
73863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73864       };
73865     }
73866   }
73867
73868   jresult = (void *)result;
73869   return jresult;
73870 }
73871
73872
73873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
73874   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73875
73876   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73877   {
73878     try {
73879       delete arg1;
73880     } catch (std::out_of_range& e) {
73881       {
73882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73883       };
73884     } catch (std::exception& e) {
73885       {
73886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73887       };
73888     } catch (Dali::DaliException e) {
73889       {
73890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73891       };
73892     } catch (...) {
73893       {
73894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73895       };
73896     }
73897   }
73898
73899 }
73900
73901
73902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
73903   void * jresult ;
73904   Dali::BaseHandle arg1 ;
73905   Dali::BaseHandle *argp1 ;
73906   Dali::Toolkit::Scrollable result;
73907
73908   argp1 = (Dali::BaseHandle *)jarg1;
73909   if (!argp1) {
73910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73911     return 0;
73912   }
73913   arg1 = *argp1;
73914   {
73915     try {
73916       result = Dali::Toolkit::Scrollable::DownCast(arg1);
73917     } catch (std::out_of_range& e) {
73918       {
73919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73920       };
73921     } catch (std::exception& e) {
73922       {
73923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73924       };
73925     } catch (Dali::DaliException e) {
73926       {
73927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73928       };
73929     } catch (...) {
73930       {
73931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73932       };
73933     }
73934   }
73935
73936   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
73937   return jresult;
73938 }
73939
73940
73941 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
73942   unsigned int jresult ;
73943   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73944   bool result;
73945
73946   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73947   {
73948     try {
73949       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
73950     } catch (std::out_of_range& e) {
73951       {
73952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73953       };
73954     } catch (std::exception& e) {
73955       {
73956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73957       };
73958     } catch (Dali::DaliException e) {
73959       {
73960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73961       };
73962     } catch (...) {
73963       {
73964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73965       };
73966     }
73967   }
73968
73969   jresult = result;
73970   return jresult;
73971 }
73972
73973
73974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
73975   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73976   bool arg2 ;
73977
73978   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73979   arg2 = jarg2 ? true : false;
73980   {
73981     try {
73982       (arg1)->SetOvershootEnabled(arg2);
73983     } catch (std::out_of_range& e) {
73984       {
73985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73986       };
73987     } catch (std::exception& e) {
73988       {
73989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73990       };
73991     } catch (Dali::DaliException e) {
73992       {
73993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73994       };
73995     } catch (...) {
73996       {
73997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73998       };
73999     }
74000   }
74001
74002 }
74003
74004
74005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
74006   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74007   Dali::Vector4 *arg2 = 0 ;
74008
74009   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74010   arg2 = (Dali::Vector4 *)jarg2;
74011   if (!arg2) {
74012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
74013     return ;
74014   }
74015   {
74016     try {
74017       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
74018     } catch (std::out_of_range& e) {
74019       {
74020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74021       };
74022     } catch (std::exception& e) {
74023       {
74024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74025       };
74026     } catch (Dali::DaliException e) {
74027       {
74028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74029       };
74030     } catch (...) {
74031       {
74032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74033       };
74034     }
74035   }
74036
74037 }
74038
74039
74040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
74041   void * jresult ;
74042   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74043   Dali::Vector4 result;
74044
74045   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74046   {
74047     try {
74048       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
74049     } catch (std::out_of_range& e) {
74050       {
74051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74052       };
74053     } catch (std::exception& e) {
74054       {
74055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74056       };
74057     } catch (Dali::DaliException e) {
74058       {
74059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74060       };
74061     } catch (...) {
74062       {
74063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74064       };
74065     }
74066   }
74067
74068   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
74069   return jresult;
74070 }
74071
74072
74073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
74074   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74075   float arg2 ;
74076
74077   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74078   arg2 = (float)jarg2;
74079   {
74080     try {
74081       (arg1)->SetOvershootAnimationSpeed(arg2);
74082     } catch (std::out_of_range& e) {
74083       {
74084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74085       };
74086     } catch (std::exception& e) {
74087       {
74088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74089       };
74090     } catch (Dali::DaliException e) {
74091       {
74092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74093       };
74094     } catch (...) {
74095       {
74096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74097       };
74098     }
74099   }
74100
74101 }
74102
74103
74104 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
74105   float jresult ;
74106   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74107   float result;
74108
74109   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74110   {
74111     try {
74112       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
74113     } catch (std::out_of_range& e) {
74114       {
74115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74116       };
74117     } catch (std::exception& e) {
74118       {
74119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74120       };
74121     } catch (Dali::DaliException e) {
74122       {
74123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74124       };
74125     } catch (...) {
74126       {
74127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74128       };
74129     }
74130   }
74131
74132   jresult = result;
74133   return jresult;
74134 }
74135
74136
74137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
74138   void * jresult ;
74139   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74140   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
74141
74142   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74143   {
74144     try {
74145       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
74146     } catch (std::out_of_range& e) {
74147       {
74148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74149       };
74150     } catch (std::exception& e) {
74151       {
74152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74153       };
74154     } catch (Dali::DaliException e) {
74155       {
74156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74157       };
74158     } catch (...) {
74159       {
74160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74161       };
74162     }
74163   }
74164
74165   jresult = (void *)result;
74166   return jresult;
74167 }
74168
74169
74170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
74171   void * jresult ;
74172   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74173   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
74174
74175   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74176   {
74177     try {
74178       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
74179     } catch (std::out_of_range& e) {
74180       {
74181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74182       };
74183     } catch (std::exception& e) {
74184       {
74185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74186       };
74187     } catch (Dali::DaliException e) {
74188       {
74189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74190       };
74191     } catch (...) {
74192       {
74193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74194       };
74195     }
74196   }
74197
74198   jresult = (void *)result;
74199   return jresult;
74200 }
74201
74202
74203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
74204   void * jresult ;
74205   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74206   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
74207
74208   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74209   {
74210     try {
74211       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
74212     } catch (std::out_of_range& e) {
74213       {
74214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74215       };
74216     } catch (std::exception& e) {
74217       {
74218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74219       };
74220     } catch (Dali::DaliException e) {
74221       {
74222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74223       };
74224     } catch (...) {
74225       {
74226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74227       };
74228     }
74229   }
74230
74231   jresult = (void *)result;
74232   return jresult;
74233 }
74234
74235
74236 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
74237   unsigned int jresult ;
74238   Dali::Toolkit::ControlOrientation::Type arg1 ;
74239   bool result;
74240
74241   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74242   {
74243     try {
74244       result = (bool)Dali::Toolkit::IsVertical(arg1);
74245     } catch (std::out_of_range& e) {
74246       {
74247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74248       };
74249     } catch (std::exception& e) {
74250       {
74251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74252       };
74253     } catch (Dali::DaliException e) {
74254       {
74255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74256       };
74257     } catch (...) {
74258       {
74259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74260       };
74261     }
74262   }
74263
74264   jresult = result;
74265   return jresult;
74266 }
74267
74268
74269 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
74270   unsigned int jresult ;
74271   Dali::Toolkit::ControlOrientation::Type arg1 ;
74272   bool result;
74273
74274   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74275   {
74276     try {
74277       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
74278     } catch (std::out_of_range& e) {
74279       {
74280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74281       };
74282     } catch (std::exception& e) {
74283       {
74284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74285       };
74286     } catch (Dali::DaliException e) {
74287       {
74288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74289       };
74290     } catch (...) {
74291       {
74292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74293       };
74294     }
74295   }
74296
74297   jresult = result;
74298   return jresult;
74299 }
74300
74301
74302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
74303   void * jresult ;
74304   unsigned int arg1 ;
74305   unsigned int arg2 ;
74306   Dali::Toolkit::ItemRange *result = 0 ;
74307
74308   arg1 = (unsigned int)jarg1;
74309   arg2 = (unsigned int)jarg2;
74310   {
74311     try {
74312       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
74313     } catch (std::out_of_range& e) {
74314       {
74315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74316       };
74317     } catch (std::exception& e) {
74318       {
74319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74320       };
74321     } catch (Dali::DaliException e) {
74322       {
74323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74324       };
74325     } catch (...) {
74326       {
74327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74328       };
74329     }
74330   }
74331
74332   jresult = (void *)result;
74333   return jresult;
74334 }
74335
74336
74337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
74338   void * jresult ;
74339   Dali::Toolkit::ItemRange *arg1 = 0 ;
74340   Dali::Toolkit::ItemRange *result = 0 ;
74341
74342   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74343   if (!arg1) {
74344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74345     return 0;
74346   }
74347   {
74348     try {
74349       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
74350     } catch (std::out_of_range& e) {
74351       {
74352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74353       };
74354     } catch (std::exception& e) {
74355       {
74356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74357       };
74358     } catch (Dali::DaliException e) {
74359       {
74360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74361       };
74362     } catch (...) {
74363       {
74364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74365       };
74366     }
74367   }
74368
74369   jresult = (void *)result;
74370   return jresult;
74371 }
74372
74373
74374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
74375   void * jresult ;
74376   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74377   Dali::Toolkit::ItemRange *arg2 = 0 ;
74378   Dali::Toolkit::ItemRange *result = 0 ;
74379
74380   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74381   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74382   if (!arg2) {
74383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74384     return 0;
74385   }
74386   {
74387     try {
74388       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
74389     } catch (std::out_of_range& e) {
74390       {
74391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74392       };
74393     } catch (std::exception& e) {
74394       {
74395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74396       };
74397     } catch (Dali::DaliException e) {
74398       {
74399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74400       };
74401     } catch (...) {
74402       {
74403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74404       };
74405     }
74406   }
74407
74408   jresult = (void *)result;
74409   return jresult;
74410 }
74411
74412
74413 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
74414   unsigned int jresult ;
74415   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74416   unsigned int arg2 ;
74417   bool result;
74418
74419   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74420   arg2 = (unsigned int)jarg2;
74421   {
74422     try {
74423       result = (bool)(arg1)->Within(arg2);
74424     } catch (std::out_of_range& e) {
74425       {
74426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74427       };
74428     } catch (std::exception& e) {
74429       {
74430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74431       };
74432     } catch (Dali::DaliException e) {
74433       {
74434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74435       };
74436     } catch (...) {
74437       {
74438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74439       };
74440     }
74441   }
74442
74443   jresult = result;
74444   return jresult;
74445 }
74446
74447
74448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
74449   void * jresult ;
74450   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74451   Dali::Toolkit::ItemRange *arg2 = 0 ;
74452   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
74453
74454   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74455   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74456   if (!arg2) {
74457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74458     return 0;
74459   }
74460   {
74461     try {
74462       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
74463     } catch (std::out_of_range& e) {
74464       {
74465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74466       };
74467     } catch (std::exception& e) {
74468       {
74469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74470       };
74471     } catch (Dali::DaliException e) {
74472       {
74473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74474       };
74475     } catch (...) {
74476       {
74477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74478       };
74479     }
74480   }
74481
74482   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
74483   return jresult;
74484 }
74485
74486
74487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
74488   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74489   unsigned int arg2 ;
74490
74491   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74492   arg2 = (unsigned int)jarg2;
74493   if (arg1) (arg1)->begin = arg2;
74494 }
74495
74496
74497 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
74498   unsigned int jresult ;
74499   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74500   unsigned int result;
74501
74502   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74503   result = (unsigned int) ((arg1)->begin);
74504   jresult = result;
74505   return jresult;
74506 }
74507
74508
74509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
74510   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74511   unsigned int arg2 ;
74512
74513   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74514   arg2 = (unsigned int)jarg2;
74515   if (arg1) (arg1)->end = arg2;
74516 }
74517
74518
74519 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
74520   unsigned int jresult ;
74521   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74522   unsigned int result;
74523
74524   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74525   result = (unsigned int) ((arg1)->end);
74526   jresult = result;
74527   return jresult;
74528 }
74529
74530
74531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
74532   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74533
74534   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74535   {
74536     try {
74537       delete arg1;
74538     } catch (std::out_of_range& e) {
74539       {
74540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74541       };
74542     } catch (std::exception& e) {
74543       {
74544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74545       };
74546     } catch (Dali::DaliException e) {
74547       {
74548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74549       };
74550     } catch (...) {
74551       {
74552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74553       };
74554     }
74555   }
74556
74557 }
74558
74559
74560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
74561   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74562
74563   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74564   {
74565     try {
74566       delete arg1;
74567     } catch (std::out_of_range& e) {
74568       {
74569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74570       };
74571     } catch (std::exception& e) {
74572       {
74573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74574       };
74575     } catch (Dali::DaliException e) {
74576       {
74577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74578       };
74579     } catch (...) {
74580       {
74581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74582       };
74583     }
74584   }
74585
74586 }
74587
74588
74589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
74590   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74591   Dali::Toolkit::ControlOrientation::Type arg2 ;
74592
74593   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74594   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
74595   {
74596     try {
74597       (arg1)->SetOrientation(arg2);
74598     } catch (std::out_of_range& e) {
74599       {
74600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74601       };
74602     } catch (std::exception& e) {
74603       {
74604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74605       };
74606     } catch (Dali::DaliException e) {
74607       {
74608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74609       };
74610     } catch (...) {
74611       {
74612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74613       };
74614     }
74615   }
74616
74617 }
74618
74619
74620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
74621   int jresult ;
74622   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74623   Dali::Toolkit::ControlOrientation::Type result;
74624
74625   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74626   {
74627     try {
74628       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
74629     } catch (std::out_of_range& e) {
74630       {
74631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74632       };
74633     } catch (std::exception& e) {
74634       {
74635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74636       };
74637     } catch (Dali::DaliException e) {
74638       {
74639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74640       };
74641     } catch (...) {
74642       {
74643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74644       };
74645     }
74646   }
74647
74648   jresult = (int)result;
74649   return jresult;
74650 }
74651
74652
74653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
74654   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74655   Dali::Property::Map *arg2 = 0 ;
74656
74657   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74658   arg2 = (Dali::Property::Map *)jarg2;
74659   if (!arg2) {
74660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
74661     return ;
74662   }
74663   {
74664     try {
74665       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
74666     } catch (std::out_of_range& e) {
74667       {
74668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74669       };
74670     } catch (std::exception& e) {
74671       {
74672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74673       };
74674     } catch (Dali::DaliException e) {
74675       {
74676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74677       };
74678     } catch (...) {
74679       {
74680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74681       };
74682     }
74683   }
74684
74685 }
74686
74687
74688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
74689   void * jresult ;
74690   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74691   Dali::Property::Map result;
74692
74693   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74694   {
74695     try {
74696       result = (arg1)->GetLayoutProperties();
74697     } catch (std::out_of_range& e) {
74698       {
74699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74700       };
74701     } catch (std::exception& e) {
74702       {
74703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74704       };
74705     } catch (Dali::DaliException e) {
74706       {
74707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74708       };
74709     } catch (...) {
74710       {
74711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74712       };
74713     }
74714   }
74715
74716   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
74717   return jresult;
74718 }
74719
74720
74721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
74722   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74723   unsigned int arg2 ;
74724   Dali::Vector3 *arg3 = 0 ;
74725   Dali::Vector3 *arg4 = 0 ;
74726
74727   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74728   arg2 = (unsigned int)jarg2;
74729   arg3 = (Dali::Vector3 *)jarg3;
74730   if (!arg3) {
74731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74732     return ;
74733   }
74734   arg4 = (Dali::Vector3 *)jarg4;
74735   if (!arg4) {
74736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
74737     return ;
74738   }
74739   {
74740     try {
74741       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
74742     } catch (std::out_of_range& e) {
74743       {
74744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74745       };
74746     } catch (std::exception& e) {
74747       {
74748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74749       };
74750     } catch (Dali::DaliException e) {
74751       {
74752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74753       };
74754     } catch (...) {
74755       {
74756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74757       };
74758     }
74759   }
74760
74761 }
74762
74763
74764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
74765   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74766   Dali::Vector3 *arg2 = 0 ;
74767
74768   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74769   arg2 = (Dali::Vector3 *)jarg2;
74770   if (!arg2) {
74771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74772     return ;
74773   }
74774   {
74775     try {
74776       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
74777     } catch (std::out_of_range& e) {
74778       {
74779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74780       };
74781     } catch (std::exception& e) {
74782       {
74783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74784       };
74785     } catch (Dali::DaliException e) {
74786       {
74787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74788       };
74789     } catch (...) {
74790       {
74791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74792       };
74793     }
74794   }
74795
74796 }
74797
74798
74799 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
74800   float jresult ;
74801   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74802   unsigned int arg2 ;
74803   Dali::Vector3 arg3 ;
74804   Dali::Vector3 *argp3 ;
74805   float result;
74806
74807   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74808   arg2 = (unsigned int)jarg2;
74809   argp3 = (Dali::Vector3 *)jarg3;
74810   if (!argp3) {
74811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
74812     return 0;
74813   }
74814   arg3 = *argp3;
74815   {
74816     try {
74817       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
74818     } catch (std::out_of_range& e) {
74819       {
74820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74821       };
74822     } catch (std::exception& e) {
74823       {
74824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74825       };
74826     } catch (Dali::DaliException e) {
74827       {
74828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74829       };
74830     } catch (...) {
74831       {
74832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74833       };
74834     }
74835   }
74836
74837   jresult = result;
74838   return jresult;
74839 }
74840
74841
74842 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
74843   float jresult ;
74844   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74845   float arg2 ;
74846   float result;
74847
74848   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74849   arg2 = (float)jarg2;
74850   {
74851     try {
74852       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
74853     } catch (std::out_of_range& e) {
74854       {
74855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74856       };
74857     } catch (std::exception& e) {
74858       {
74859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74860       };
74861     } catch (Dali::DaliException e) {
74862       {
74863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74864       };
74865     } catch (...) {
74866       {
74867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74868       };
74869     }
74870   }
74871
74872   jresult = result;
74873   return jresult;
74874 }
74875
74876
74877 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
74878   float jresult ;
74879   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74880   unsigned int arg2 ;
74881   float result;
74882
74883   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74884   arg2 = (unsigned int)jarg2;
74885   {
74886     try {
74887       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
74888     } catch (std::out_of_range& e) {
74889       {
74890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74891       };
74892     } catch (std::exception& e) {
74893       {
74894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74895       };
74896     } catch (Dali::DaliException e) {
74897       {
74898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74899       };
74900     } catch (...) {
74901       {
74902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74903       };
74904     }
74905   }
74906
74907   jresult = result;
74908   return jresult;
74909 }
74910
74911
74912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
74913   void * jresult ;
74914   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74915   float arg2 ;
74916   Dali::Vector3 arg3 ;
74917   Dali::Vector3 *argp3 ;
74918   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
74919
74920   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74921   arg2 = (float)jarg2;
74922   argp3 = (Dali::Vector3 *)jarg3;
74923   if (!argp3) {
74924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
74925     return 0;
74926   }
74927   arg3 = *argp3;
74928   {
74929     try {
74930       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
74931     } catch (std::out_of_range& e) {
74932       {
74933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74934       };
74935     } catch (std::exception& e) {
74936       {
74937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74938       };
74939     } catch (Dali::DaliException e) {
74940       {
74941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74942       };
74943     } catch (...) {
74944       {
74945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74946       };
74947     }
74948   }
74949
74950   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
74951   return jresult;
74952 }
74953
74954
74955 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
74956   float jresult ;
74957   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74958   int arg2 ;
74959   float arg3 ;
74960   Dali::Vector3 *arg4 = 0 ;
74961   float result;
74962
74963   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74964   arg2 = (int)jarg2;
74965   arg3 = (float)jarg3;
74966   arg4 = (Dali::Vector3 *)jarg4;
74967   if (!arg4) {
74968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74969     return 0;
74970   }
74971   {
74972     try {
74973       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
74974     } catch (std::out_of_range& e) {
74975       {
74976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74977       };
74978     } catch (std::exception& e) {
74979       {
74980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74981       };
74982     } catch (Dali::DaliException e) {
74983       {
74984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74985       };
74986     } catch (...) {
74987       {
74988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74989       };
74990     }
74991   }
74992
74993   jresult = result;
74994   return jresult;
74995 }
74996
74997
74998 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
74999   unsigned int jresult ;
75000   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75001   Dali::Vector3 arg2 ;
75002   Dali::Vector3 *argp2 ;
75003   unsigned int result;
75004
75005   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75006   argp2 = (Dali::Vector3 *)jarg2;
75007   if (!argp2) {
75008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75009     return 0;
75010   }
75011   arg2 = *argp2;
75012   {
75013     try {
75014       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
75015     } catch (std::out_of_range& e) {
75016       {
75017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75018       };
75019     } catch (std::exception& e) {
75020       {
75021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75022       };
75023     } catch (Dali::DaliException e) {
75024       {
75025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75026       };
75027     } catch (...) {
75028       {
75029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75030       };
75031     }
75032   }
75033
75034   jresult = result;
75035   return jresult;
75036 }
75037
75038
75039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
75040   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75041   unsigned int arg2 ;
75042   Dali::Vector3 *arg3 = 0 ;
75043   Dali::Vector3 *arg4 = 0 ;
75044
75045   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75046   arg2 = (unsigned int)jarg2;
75047   arg3 = (Dali::Vector3 *)jarg3;
75048   if (!arg3) {
75049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75050     return ;
75051   }
75052   arg4 = (Dali::Vector3 *)jarg4;
75053   if (!arg4) {
75054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
75055     return ;
75056   }
75057   {
75058     try {
75059       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
75060     } catch (std::out_of_range& e) {
75061       {
75062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75063       };
75064     } catch (std::exception& e) {
75065       {
75066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75067       };
75068     } catch (Dali::DaliException e) {
75069       {
75070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75071       };
75072     } catch (...) {
75073       {
75074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75075       };
75076     }
75077   }
75078
75079 }
75080
75081
75082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
75083   void * jresult ;
75084   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75085   Dali::Degree result;
75086
75087   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75088   {
75089     try {
75090       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
75091     } catch (std::out_of_range& e) {
75092       {
75093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75094       };
75095     } catch (std::exception& e) {
75096       {
75097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75098       };
75099     } catch (Dali::DaliException e) {
75100       {
75101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75102       };
75103     } catch (...) {
75104       {
75105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75106       };
75107     }
75108   }
75109
75110   jresult = new Dali::Degree((const Dali::Degree &)result);
75111   return jresult;
75112 }
75113
75114
75115 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
75116   float jresult ;
75117   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75118   float result;
75119
75120   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75121   {
75122     try {
75123       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
75124     } catch (std::out_of_range& e) {
75125       {
75126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75127       };
75128     } catch (std::exception& e) {
75129       {
75130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75131       };
75132     } catch (Dali::DaliException e) {
75133       {
75134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75135       };
75136     } catch (...) {
75137       {
75138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75139       };
75140     }
75141   }
75142
75143   jresult = result;
75144   return jresult;
75145 }
75146
75147
75148 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
75149   float jresult ;
75150   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75151   float result;
75152
75153   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75154   {
75155     try {
75156       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
75157     } catch (std::out_of_range& e) {
75158       {
75159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75160       };
75161     } catch (std::exception& e) {
75162       {
75163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75164       };
75165     } catch (Dali::DaliException e) {
75166       {
75167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75168       };
75169     } catch (...) {
75170       {
75171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75172       };
75173     }
75174   }
75175
75176   jresult = result;
75177   return jresult;
75178 }
75179
75180
75181 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
75182   float jresult ;
75183   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75184   float result;
75185
75186   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75187   {
75188     try {
75189       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
75190     } catch (std::out_of_range& e) {
75191       {
75192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75193       };
75194     } catch (std::exception& e) {
75195       {
75196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75197       };
75198     } catch (Dali::DaliException e) {
75199       {
75200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75201       };
75202     } catch (...) {
75203       {
75204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75205       };
75206     }
75207   }
75208
75209   jresult = result;
75210   return jresult;
75211 }
75212
75213
75214 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
75215   int jresult ;
75216   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75217   int arg2 ;
75218   int arg3 ;
75219   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
75220   bool arg5 ;
75221   int result;
75222
75223   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75224   arg2 = (int)jarg2;
75225   arg3 = (int)jarg3;
75226   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
75227   arg5 = jarg5 ? true : false;
75228   {
75229     try {
75230       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
75231     } catch (std::out_of_range& e) {
75232       {
75233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75234       };
75235     } catch (std::exception& e) {
75236       {
75237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75238       };
75239     } catch (Dali::DaliException e) {
75240       {
75241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75242       };
75243     } catch (...) {
75244       {
75245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75246       };
75247     }
75248   }
75249
75250   jresult = result;
75251   return jresult;
75252 }
75253
75254
75255 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
75256   float jresult ;
75257   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75258   float result;
75259
75260   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75261   {
75262     try {
75263       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
75264     } catch (std::out_of_range& e) {
75265       {
75266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75267       };
75268     } catch (std::exception& e) {
75269       {
75270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75271       };
75272     } catch (Dali::DaliException e) {
75273       {
75274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75275       };
75276     } catch (...) {
75277       {
75278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75279       };
75280     }
75281   }
75282
75283   jresult = result;
75284   return jresult;
75285 }
75286
75287
75288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
75289   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75290   Dali::Actor *arg2 = 0 ;
75291   int arg3 ;
75292   Dali::Vector3 *arg4 = 0 ;
75293   Dali::Actor *arg5 = 0 ;
75294
75295   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75296   arg2 = (Dali::Actor *)jarg2;
75297   if (!arg2) {
75298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75299     return ;
75300   }
75301   arg3 = (int)jarg3;
75302   arg4 = (Dali::Vector3 *)jarg4;
75303   if (!arg4) {
75304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75305     return ;
75306   }
75307   arg5 = (Dali::Actor *)jarg5;
75308   if (!arg5) {
75309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
75310     return ;
75311   }
75312   {
75313     try {
75314       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
75315     } catch (std::out_of_range& e) {
75316       {
75317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75318       };
75319     } catch (std::exception& e) {
75320       {
75321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75322       };
75323     } catch (Dali::DaliException e) {
75324       {
75325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75326       };
75327     } catch (...) {
75328       {
75329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75330       };
75331     }
75332   }
75333
75334 }
75335
75336
75337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75338   void * jresult ;
75339   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75340   int arg2 ;
75341   float arg3 ;
75342   Dali::Vector3 *arg4 = 0 ;
75343   Dali::Vector3 result;
75344
75345   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75346   arg2 = (int)jarg2;
75347   arg3 = (float)jarg3;
75348   arg4 = (Dali::Vector3 *)jarg4;
75349   if (!arg4) {
75350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75351     return 0;
75352   }
75353   {
75354     try {
75355       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75356     } catch (std::out_of_range& e) {
75357       {
75358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75359       };
75360     } catch (std::exception& e) {
75361       {
75362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75363       };
75364     } catch (Dali::DaliException e) {
75365       {
75366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75367       };
75368     } catch (...) {
75369       {
75370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75371       };
75372     }
75373   }
75374
75375   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
75376   return jresult;
75377 }
75378
75379
75380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
75381   void * jresult ;
75382   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
75383   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75384
75385   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
75386   {
75387     try {
75388       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
75389     } catch (std::out_of_range& e) {
75390       {
75391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75392       };
75393     } catch (std::exception& e) {
75394       {
75395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75396       };
75397     } catch (Dali::DaliException e) {
75398       {
75399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75400       };
75401     } catch (...) {
75402       {
75403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75404       };
75405     }
75406   }
75407
75408   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75409   return jresult;
75410 }
75411
75412
75413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
75414   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75415
75416   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75417   {
75418     try {
75419       delete arg1;
75420     } catch (std::out_of_range& e) {
75421       {
75422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75423       };
75424     } catch (std::exception& e) {
75425       {
75426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75427       };
75428     } catch (Dali::DaliException e) {
75429       {
75430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75431       };
75432     } catch (...) {
75433       {
75434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75435       };
75436     }
75437   }
75438
75439 }
75440
75441
75442 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
75443   unsigned int jresult ;
75444   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75445   unsigned int result;
75446
75447   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75448   {
75449     try {
75450       result = (unsigned int)(arg1)->GetNumberOfItems();
75451     } catch (std::out_of_range& e) {
75452       {
75453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75454       };
75455     } catch (std::exception& e) {
75456       {
75457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75458       };
75459     } catch (Dali::DaliException e) {
75460       {
75461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75462       };
75463     } catch (...) {
75464       {
75465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75466       };
75467     }
75468   }
75469
75470   jresult = result;
75471   return jresult;
75472 }
75473
75474
75475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
75476   void * jresult ;
75477   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75478   unsigned int arg2 ;
75479   Dali::Actor result;
75480
75481   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75482   arg2 = (unsigned int)jarg2;
75483   {
75484     try {
75485       result = (arg1)->NewItem(arg2);
75486     } catch (std::out_of_range& e) {
75487       {
75488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75489       };
75490     } catch (std::exception& e) {
75491       {
75492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75493       };
75494     } catch (Dali::DaliException e) {
75495       {
75496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75497       };
75498     } catch (...) {
75499       {
75500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75501       };
75502     }
75503   }
75504
75505   jresult = new Dali::Actor((const Dali::Actor &)result);
75506   return jresult;
75507 }
75508
75509
75510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
75511   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75512   unsigned int arg2 ;
75513   Dali::Actor arg3 ;
75514   Dali::Actor *argp3 ;
75515
75516   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75517   arg2 = (unsigned int)jarg2;
75518   argp3 = (Dali::Actor *)jarg3;
75519   if (!argp3) {
75520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75521     return ;
75522   }
75523   arg3 = *argp3;
75524   {
75525     try {
75526       (arg1)->ItemReleased(arg2,arg3);
75527     } catch (std::out_of_range& e) {
75528       {
75529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75530       };
75531     } catch (std::exception& e) {
75532       {
75533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75534       };
75535     } catch (Dali::DaliException e) {
75536       {
75537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75538       };
75539     } catch (...) {
75540       {
75541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75542       };
75543     }
75544   }
75545
75546 }
75547
75548
75549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
75550   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75551   unsigned int arg2 ;
75552   Dali::Actor arg3 ;
75553   Dali::Actor *argp3 ;
75554
75555   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75556   arg2 = (unsigned int)jarg2;
75557   argp3 = (Dali::Actor *)jarg3;
75558   if (!argp3) {
75559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75560     return ;
75561   }
75562   arg3 = *argp3;
75563   {
75564     try {
75565       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
75566     } catch (std::out_of_range& e) {
75567       {
75568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75569       };
75570     } catch (std::exception& e) {
75571       {
75572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75573       };
75574     } catch (Dali::DaliException e) {
75575       {
75576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75577       };
75578     } catch (...) {
75579       {
75580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75581       };
75582     }
75583   }
75584
75585 }
75586
75587
75588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
75589   void * jresult ;
75590   Dali::Toolkit::ItemFactory *result = 0 ;
75591
75592   {
75593     try {
75594       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
75595     } catch (std::out_of_range& e) {
75596       {
75597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75598       };
75599     } catch (std::exception& e) {
75600       {
75601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75602       };
75603     } catch (Dali::DaliException e) {
75604       {
75605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75606       };
75607     } catch (...) {
75608       {
75609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75610       };
75611     }
75612   }
75613
75614   jresult = (void *)result;
75615   return jresult;
75616 }
75617
75618
75619 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) {
75620   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
75621   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
75622   if (director) {
75623     director->swig_connect_director(callback0, callback1, callback2);
75624   }
75625 }
75626
75627
75628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
75629   int jresult ;
75630   int result;
75631
75632   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
75633   jresult = (int)result;
75634   return jresult;
75635 }
75636
75637
75638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
75639   int jresult ;
75640   int result;
75641
75642   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
75643   jresult = (int)result;
75644   return jresult;
75645 }
75646
75647
75648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
75649   int jresult ;
75650   int result;
75651
75652   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
75653   jresult = (int)result;
75654   return jresult;
75655 }
75656
75657
75658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
75659   int jresult ;
75660   int result;
75661
75662   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
75663   jresult = (int)result;
75664   return jresult;
75665 }
75666
75667
75668 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
75669   int jresult ;
75670   int result;
75671
75672   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
75673   jresult = (int)result;
75674   return jresult;
75675 }
75676
75677
75678 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
75679   int jresult ;
75680   int result;
75681
75682   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
75683   jresult = (int)result;
75684   return jresult;
75685 }
75686
75687
75688 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
75689   int jresult ;
75690   int result;
75691
75692   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
75693   jresult = (int)result;
75694   return jresult;
75695 }
75696
75697
75698 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
75699   int jresult ;
75700   int result;
75701
75702   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
75703   jresult = (int)result;
75704   return jresult;
75705 }
75706
75707
75708 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
75709   int jresult ;
75710   int result;
75711
75712   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
75713   jresult = (int)result;
75714   return jresult;
75715 }
75716
75717
75718 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
75719   int jresult ;
75720   int result;
75721
75722   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
75723   jresult = (int)result;
75724   return jresult;
75725 }
75726
75727
75728 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
75729   int jresult ;
75730   int result;
75731
75732   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
75733   jresult = (int)result;
75734   return jresult;
75735 }
75736
75737
75738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
75739   void * jresult ;
75740   Dali::Toolkit::ItemView::Property *result = 0 ;
75741
75742   {
75743     try {
75744       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
75745     } catch (std::out_of_range& e) {
75746       {
75747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75748       };
75749     } catch (std::exception& e) {
75750       {
75751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75752       };
75753     } catch (Dali::DaliException e) {
75754       {
75755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75756       };
75757     } catch (...) {
75758       {
75759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75760       };
75761     }
75762   }
75763
75764   jresult = (void *)result;
75765   return jresult;
75766 }
75767
75768
75769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
75770   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
75771
75772   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
75773   {
75774     try {
75775       delete arg1;
75776     } catch (std::out_of_range& e) {
75777       {
75778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75779       };
75780     } catch (std::exception& e) {
75781       {
75782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75783       };
75784     } catch (Dali::DaliException e) {
75785       {
75786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75787       };
75788     } catch (...) {
75789       {
75790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75791       };
75792     }
75793   }
75794
75795 }
75796
75797
75798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
75799   void * jresult ;
75800   Dali::Toolkit::ItemView *result = 0 ;
75801
75802   {
75803     try {
75804       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
75805     } catch (std::out_of_range& e) {
75806       {
75807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75808       };
75809     } catch (std::exception& e) {
75810       {
75811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75812       };
75813     } catch (Dali::DaliException e) {
75814       {
75815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75816       };
75817     } catch (...) {
75818       {
75819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75820       };
75821     }
75822   }
75823
75824   jresult = (void *)result;
75825   return jresult;
75826 }
75827
75828
75829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
75830   void * jresult ;
75831   Dali::Toolkit::ItemView *arg1 = 0 ;
75832   Dali::Toolkit::ItemView *result = 0 ;
75833
75834   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75835   if (!arg1) {
75836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
75837     return 0;
75838   }
75839   {
75840     try {
75841       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
75842     } catch (std::out_of_range& e) {
75843       {
75844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75845       };
75846     } catch (std::exception& e) {
75847       {
75848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75849       };
75850     } catch (Dali::DaliException e) {
75851       {
75852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75853       };
75854     } catch (...) {
75855       {
75856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75857       };
75858     }
75859   }
75860
75861   jresult = (void *)result;
75862   return jresult;
75863 }
75864
75865
75866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
75867   void * jresult ;
75868   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75869   Dali::Toolkit::ItemView *arg2 = 0 ;
75870   Dali::Toolkit::ItemView *result = 0 ;
75871
75872   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75873   arg2 = (Dali::Toolkit::ItemView *)jarg2;
75874   if (!arg2) {
75875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
75876     return 0;
75877   }
75878   {
75879     try {
75880       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
75881     } catch (std::out_of_range& e) {
75882       {
75883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75884       };
75885     } catch (std::exception& e) {
75886       {
75887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75888       };
75889     } catch (Dali::DaliException e) {
75890       {
75891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75892       };
75893     } catch (...) {
75894       {
75895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75896       };
75897     }
75898   }
75899
75900   jresult = (void *)result;
75901   return jresult;
75902 }
75903
75904
75905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
75906   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75907
75908   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75909   {
75910     try {
75911       delete arg1;
75912     } catch (std::out_of_range& e) {
75913       {
75914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75915       };
75916     } catch (std::exception& e) {
75917       {
75918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75919       };
75920     } catch (Dali::DaliException e) {
75921       {
75922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75923       };
75924     } catch (...) {
75925       {
75926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75927       };
75928     }
75929   }
75930
75931 }
75932
75933
75934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
75935   void * jresult ;
75936   Dali::Toolkit::ItemFactory *arg1 = 0 ;
75937   Dali::Toolkit::ItemView result;
75938
75939   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75940   if (!arg1) {
75941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
75942     return 0;
75943   }
75944   {
75945     try {
75946       result = Dali::Toolkit::ItemView::New(*arg1);
75947     } catch (std::out_of_range& e) {
75948       {
75949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75950       };
75951     } catch (std::exception& e) {
75952       {
75953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75954       };
75955     } catch (Dali::DaliException e) {
75956       {
75957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75958       };
75959     } catch (...) {
75960       {
75961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75962       };
75963     }
75964   }
75965
75966   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
75967   return jresult;
75968 }
75969
75970
75971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
75972   void * jresult ;
75973   Dali::BaseHandle arg1 ;
75974   Dali::BaseHandle *argp1 ;
75975   Dali::Toolkit::ItemView result;
75976
75977   argp1 = (Dali::BaseHandle *)jarg1;
75978   if (!argp1) {
75979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
75980     return 0;
75981   }
75982   arg1 = *argp1;
75983   {
75984     try {
75985       result = Dali::Toolkit::ItemView::DownCast(arg1);
75986     } catch (std::out_of_range& e) {
75987       {
75988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75989       };
75990     } catch (std::exception& e) {
75991       {
75992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75993       };
75994     } catch (Dali::DaliException e) {
75995       {
75996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75997       };
75998     } catch (...) {
75999       {
76000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76001       };
76002     }
76003   }
76004
76005   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
76006   return jresult;
76007 }
76008
76009
76010 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
76011   unsigned int jresult ;
76012   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76013   unsigned int result;
76014
76015   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76016   {
76017     try {
76018       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
76019     } catch (std::out_of_range& e) {
76020       {
76021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76022       };
76023     } catch (std::exception& e) {
76024       {
76025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76026       };
76027     } catch (Dali::DaliException e) {
76028       {
76029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76030       };
76031     } catch (...) {
76032       {
76033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76034       };
76035     }
76036   }
76037
76038   jresult = result;
76039   return jresult;
76040 }
76041
76042
76043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
76044   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76045   Dali::Toolkit::ItemLayout *arg2 = 0 ;
76046
76047   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76048   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
76049   if (!arg2) {
76050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
76051     return ;
76052   }
76053   {
76054     try {
76055       (arg1)->AddLayout(*arg2);
76056     } catch (std::out_of_range& e) {
76057       {
76058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76059       };
76060     } catch (std::exception& e) {
76061       {
76062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76063       };
76064     } catch (Dali::DaliException e) {
76065       {
76066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76067       };
76068     } catch (...) {
76069       {
76070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76071       };
76072     }
76073   }
76074
76075 }
76076
76077
76078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
76079   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76080   unsigned int arg2 ;
76081
76082   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76083   arg2 = (unsigned int)jarg2;
76084   {
76085     try {
76086       (arg1)->RemoveLayout(arg2);
76087     } catch (std::out_of_range& e) {
76088       {
76089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76090       };
76091     } catch (std::exception& e) {
76092       {
76093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76094       };
76095     } catch (Dali::DaliException e) {
76096       {
76097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76098       };
76099     } catch (...) {
76100       {
76101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76102       };
76103     }
76104   }
76105
76106 }
76107
76108
76109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
76110   void * jresult ;
76111   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76112   unsigned int arg2 ;
76113   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76114
76115   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76116   arg2 = (unsigned int)jarg2;
76117   {
76118     try {
76119       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
76120     } catch (std::out_of_range& e) {
76121       {
76122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76123       };
76124     } catch (std::exception& e) {
76125       {
76126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76127       };
76128     } catch (Dali::DaliException e) {
76129       {
76130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76131       };
76132     } catch (...) {
76133       {
76134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76135       };
76136     }
76137   }
76138
76139   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76140   return jresult;
76141 }
76142
76143
76144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
76145   void * jresult ;
76146   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76147   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76148
76149   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76150   {
76151     try {
76152       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
76153     } catch (std::out_of_range& e) {
76154       {
76155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76156       };
76157     } catch (std::exception& e) {
76158       {
76159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76160       };
76161     } catch (Dali::DaliException e) {
76162       {
76163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76164       };
76165     } catch (...) {
76166       {
76167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76168       };
76169     }
76170   }
76171
76172   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76173   return jresult;
76174 }
76175
76176
76177 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
76178   float jresult ;
76179   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76180   Dali::Toolkit::ItemId arg2 ;
76181   float result;
76182
76183   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76184   arg2 = (Dali::Toolkit::ItemId)jarg2;
76185   {
76186     try {
76187       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
76188     } catch (std::out_of_range& e) {
76189       {
76190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76191       };
76192     } catch (std::exception& e) {
76193       {
76194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76195       };
76196     } catch (Dali::DaliException e) {
76197       {
76198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76199       };
76200     } catch (...) {
76201       {
76202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76203       };
76204     }
76205   }
76206
76207   jresult = result;
76208   return jresult;
76209 }
76210
76211
76212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
76213   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76214   unsigned int arg2 ;
76215   Dali::Vector3 arg3 ;
76216   float arg4 ;
76217   Dali::Vector3 *argp3 ;
76218
76219   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76220   arg2 = (unsigned int)jarg2;
76221   argp3 = (Dali::Vector3 *)jarg3;
76222   if (!argp3) {
76223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
76224     return ;
76225   }
76226   arg3 = *argp3;
76227   arg4 = (float)jarg4;
76228   {
76229     try {
76230       (arg1)->ActivateLayout(arg2,arg3,arg4);
76231     } catch (std::out_of_range& e) {
76232       {
76233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76234       };
76235     } catch (std::exception& e) {
76236       {
76237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76238       };
76239     } catch (Dali::DaliException e) {
76240       {
76241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76242       };
76243     } catch (...) {
76244       {
76245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76246       };
76247     }
76248   }
76249
76250 }
76251
76252
76253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
76254   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76255
76256   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76257   {
76258     try {
76259       (arg1)->DeactivateCurrentLayout();
76260     } catch (std::out_of_range& e) {
76261       {
76262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76263       };
76264     } catch (std::exception& e) {
76265       {
76266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76267       };
76268     } catch (Dali::DaliException e) {
76269       {
76270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76271       };
76272     } catch (...) {
76273       {
76274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76275       };
76276     }
76277   }
76278
76279 }
76280
76281
76282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
76283   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76284   float arg2 ;
76285
76286   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76287   arg2 = (float)jarg2;
76288   {
76289     try {
76290       (arg1)->SetMinimumSwipeSpeed(arg2);
76291     } catch (std::out_of_range& e) {
76292       {
76293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76294       };
76295     } catch (std::exception& e) {
76296       {
76297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76298       };
76299     } catch (Dali::DaliException e) {
76300       {
76301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76302       };
76303     } catch (...) {
76304       {
76305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76306       };
76307     }
76308   }
76309
76310 }
76311
76312
76313 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
76314   float jresult ;
76315   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76316   float result;
76317
76318   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76319   {
76320     try {
76321       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
76322     } catch (std::out_of_range& e) {
76323       {
76324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76325       };
76326     } catch (std::exception& e) {
76327       {
76328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76329       };
76330     } catch (Dali::DaliException e) {
76331       {
76332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76333       };
76334     } catch (...) {
76335       {
76336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76337       };
76338     }
76339   }
76340
76341   jresult = result;
76342   return jresult;
76343 }
76344
76345
76346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
76347   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76348   float arg2 ;
76349
76350   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76351   arg2 = (float)jarg2;
76352   {
76353     try {
76354       (arg1)->SetMinimumSwipeDistance(arg2);
76355     } catch (std::out_of_range& e) {
76356       {
76357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76358       };
76359     } catch (std::exception& e) {
76360       {
76361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76362       };
76363     } catch (Dali::DaliException e) {
76364       {
76365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76366       };
76367     } catch (...) {
76368       {
76369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76370       };
76371     }
76372   }
76373
76374 }
76375
76376
76377 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
76378   float jresult ;
76379   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76380   float result;
76381
76382   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76383   {
76384     try {
76385       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
76386     } catch (std::out_of_range& e) {
76387       {
76388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76389       };
76390     } catch (std::exception& e) {
76391       {
76392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76393       };
76394     } catch (Dali::DaliException e) {
76395       {
76396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76397       };
76398     } catch (...) {
76399       {
76400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76401       };
76402     }
76403   }
76404
76405   jresult = result;
76406   return jresult;
76407 }
76408
76409
76410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
76411   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76412   float arg2 ;
76413
76414   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76415   arg2 = (float)jarg2;
76416   {
76417     try {
76418       (arg1)->SetWheelScrollDistanceStep(arg2);
76419     } catch (std::out_of_range& e) {
76420       {
76421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76422       };
76423     } catch (std::exception& e) {
76424       {
76425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76426       };
76427     } catch (Dali::DaliException e) {
76428       {
76429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76430       };
76431     } catch (...) {
76432       {
76433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76434       };
76435     }
76436   }
76437
76438 }
76439
76440
76441 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
76442   float jresult ;
76443   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76444   float result;
76445
76446   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76447   {
76448     try {
76449       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
76450     } catch (std::out_of_range& e) {
76451       {
76452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76453       };
76454     } catch (std::exception& e) {
76455       {
76456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76457       };
76458     } catch (Dali::DaliException e) {
76459       {
76460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76461       };
76462     } catch (...) {
76463       {
76464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76465       };
76466     }
76467   }
76468
76469   jresult = result;
76470   return jresult;
76471 }
76472
76473
76474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
76475   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76476   bool arg2 ;
76477
76478   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76479   arg2 = jarg2 ? true : false;
76480   {
76481     try {
76482       (arg1)->SetAnchoring(arg2);
76483     } catch (std::out_of_range& e) {
76484       {
76485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76486       };
76487     } catch (std::exception& e) {
76488       {
76489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76490       };
76491     } catch (Dali::DaliException e) {
76492       {
76493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76494       };
76495     } catch (...) {
76496       {
76497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76498       };
76499     }
76500   }
76501
76502 }
76503
76504 //// ========================= end of part 3 =============================
76505
76506 //// ========================== start part 4 ===============================
76507
76508
76509 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
76510   unsigned int jresult ;
76511   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76512   bool result;
76513
76514   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76515   {
76516     try {
76517       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
76518     } catch (std::out_of_range& e) {
76519       {
76520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76521       };
76522     } catch (std::exception& e) {
76523       {
76524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76525       };
76526     } catch (Dali::DaliException e) {
76527       {
76528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76529       };
76530     } catch (...) {
76531       {
76532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76533       };
76534     }
76535   }
76536
76537   jresult = result;
76538   return jresult;
76539 }
76540
76541
76542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
76543   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76544   float arg2 ;
76545
76546   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76547   arg2 = (float)jarg2;
76548   {
76549     try {
76550       (arg1)->SetAnchoringDuration(arg2);
76551     } catch (std::out_of_range& e) {
76552       {
76553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76554       };
76555     } catch (std::exception& e) {
76556       {
76557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76558       };
76559     } catch (Dali::DaliException e) {
76560       {
76561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76562       };
76563     } catch (...) {
76564       {
76565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76566       };
76567     }
76568   }
76569
76570 }
76571
76572
76573 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
76574   float jresult ;
76575   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76576   float result;
76577
76578   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76579   {
76580     try {
76581       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
76582     } catch (std::out_of_range& e) {
76583       {
76584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76585       };
76586     } catch (std::exception& e) {
76587       {
76588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76589       };
76590     } catch (Dali::DaliException e) {
76591       {
76592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76593       };
76594     } catch (...) {
76595       {
76596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76597       };
76598     }
76599   }
76600
76601   jresult = result;
76602   return jresult;
76603 }
76604
76605
76606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
76607   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76608   Dali::Toolkit::ItemId arg2 ;
76609   float arg3 ;
76610
76611   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76612   arg2 = (Dali::Toolkit::ItemId)jarg2;
76613   arg3 = (float)jarg3;
76614   {
76615     try {
76616       (arg1)->ScrollToItem(arg2,arg3);
76617     } catch (std::out_of_range& e) {
76618       {
76619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76620       };
76621     } catch (std::exception& e) {
76622       {
76623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76624       };
76625     } catch (Dali::DaliException e) {
76626       {
76627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76628       };
76629     } catch (...) {
76630       {
76631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76632       };
76633     }
76634   }
76635
76636 }
76637
76638
76639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
76640   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76641   float arg2 ;
76642
76643   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76644   arg2 = (float)jarg2;
76645   {
76646     try {
76647       (arg1)->SetRefreshInterval(arg2);
76648     } catch (std::out_of_range& e) {
76649       {
76650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76651       };
76652     } catch (std::exception& e) {
76653       {
76654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76655       };
76656     } catch (Dali::DaliException e) {
76657       {
76658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76659       };
76660     } catch (...) {
76661       {
76662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76663       };
76664     }
76665   }
76666
76667 }
76668
76669
76670 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
76671   float jresult ;
76672   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76673   float result;
76674
76675   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76676   {
76677     try {
76678       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
76679     } catch (std::out_of_range& e) {
76680       {
76681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76682       };
76683     } catch (std::exception& e) {
76684       {
76685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76686       };
76687     } catch (Dali::DaliException e) {
76688       {
76689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76690       };
76691     } catch (...) {
76692       {
76693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76694       };
76695     }
76696   }
76697
76698   jresult = result;
76699   return jresult;
76700 }
76701
76702
76703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
76704   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76705
76706   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76707   {
76708     try {
76709       (arg1)->Refresh();
76710     } catch (std::out_of_range& e) {
76711       {
76712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76713       };
76714     } catch (std::exception& e) {
76715       {
76716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76717       };
76718     } catch (Dali::DaliException e) {
76719       {
76720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76721       };
76722     } catch (...) {
76723       {
76724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76725       };
76726     }
76727   }
76728
76729 }
76730
76731
76732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
76733   void * jresult ;
76734   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76735   Dali::Toolkit::ItemId arg2 ;
76736   Dali::Actor result;
76737
76738   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76739   arg2 = (Dali::Toolkit::ItemId)jarg2;
76740   {
76741     try {
76742       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
76743     } catch (std::out_of_range& e) {
76744       {
76745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76746       };
76747     } catch (std::exception& e) {
76748       {
76749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76750       };
76751     } catch (Dali::DaliException e) {
76752       {
76753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76754       };
76755     } catch (...) {
76756       {
76757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76758       };
76759     }
76760   }
76761
76762   jresult = new Dali::Actor((const Dali::Actor &)result);
76763   return jresult;
76764 }
76765
76766
76767 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
76768   unsigned int jresult ;
76769   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76770   Dali::Actor arg2 ;
76771   Dali::Actor *argp2 ;
76772   Dali::Toolkit::ItemId result;
76773
76774   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76775   argp2 = (Dali::Actor *)jarg2;
76776   if (!argp2) {
76777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76778     return 0;
76779   }
76780   arg2 = *argp2;
76781   {
76782     try {
76783       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
76784     } catch (std::out_of_range& e) {
76785       {
76786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76787       };
76788     } catch (std::exception& e) {
76789       {
76790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76791       };
76792     } catch (Dali::DaliException e) {
76793       {
76794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76795       };
76796     } catch (...) {
76797       {
76798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76799       };
76800     }
76801   }
76802
76803   jresult = result;
76804   return jresult;
76805 }
76806
76807
76808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
76809   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76810   Dali::Toolkit::Item arg2 ;
76811   float arg3 ;
76812   Dali::Toolkit::Item *argp2 ;
76813
76814   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76815   argp2 = (Dali::Toolkit::Item *)jarg2;
76816   if (!argp2) {
76817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
76818     return ;
76819   }
76820   arg2 = *argp2;
76821   arg3 = (float)jarg3;
76822   {
76823     try {
76824       (arg1)->InsertItem(arg2,arg3);
76825     } catch (std::out_of_range& e) {
76826       {
76827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76828       };
76829     } catch (std::exception& e) {
76830       {
76831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76832       };
76833     } catch (Dali::DaliException e) {
76834       {
76835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76836       };
76837     } catch (...) {
76838       {
76839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76840       };
76841     }
76842   }
76843
76844 }
76845
76846
76847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
76848   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76849   Dali::Toolkit::ItemContainer *arg2 = 0 ;
76850   float arg3 ;
76851
76852   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76853   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
76854   if (!arg2) {
76855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
76856     return ;
76857   }
76858   arg3 = (float)jarg3;
76859   {
76860     try {
76861       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
76862     } catch (std::out_of_range& e) {
76863       {
76864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76865       };
76866     } catch (std::exception& e) {
76867       {
76868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76869       };
76870     } catch (Dali::DaliException e) {
76871       {
76872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76873       };
76874     } catch (...) {
76875       {
76876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76877       };
76878     }
76879   }
76880
76881 }
76882
76883
76884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
76885   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76886   Dali::Toolkit::ItemId arg2 ;
76887   float arg3 ;
76888
76889   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76890   arg2 = (Dali::Toolkit::ItemId)jarg2;
76891   arg3 = (float)jarg3;
76892   {
76893     try {
76894       (arg1)->RemoveItem(arg2,arg3);
76895     } catch (std::out_of_range& e) {
76896       {
76897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76898       };
76899     } catch (std::exception& e) {
76900       {
76901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76902       };
76903     } catch (Dali::DaliException e) {
76904       {
76905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76906       };
76907     } catch (...) {
76908       {
76909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76910       };
76911     }
76912   }
76913
76914 }
76915
76916
76917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
76918   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76919   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
76920   float arg3 ;
76921
76922   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76923   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
76924   if (!arg2) {
76925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
76926     return ;
76927   }
76928   arg3 = (float)jarg3;
76929   {
76930     try {
76931       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
76932     } catch (std::out_of_range& e) {
76933       {
76934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76935       };
76936     } catch (std::exception& e) {
76937       {
76938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76939       };
76940     } catch (Dali::DaliException e) {
76941       {
76942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76943       };
76944     } catch (...) {
76945       {
76946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76947       };
76948     }
76949   }
76950
76951 }
76952
76953
76954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
76955   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76956   Dali::Toolkit::Item arg2 ;
76957   float arg3 ;
76958   Dali::Toolkit::Item *argp2 ;
76959
76960   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76961   argp2 = (Dali::Toolkit::Item *)jarg2;
76962   if (!argp2) {
76963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
76964     return ;
76965   }
76966   arg2 = *argp2;
76967   arg3 = (float)jarg3;
76968   {
76969     try {
76970       (arg1)->ReplaceItem(arg2,arg3);
76971     } catch (std::out_of_range& e) {
76972       {
76973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76974       };
76975     } catch (std::exception& e) {
76976       {
76977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76978       };
76979     } catch (Dali::DaliException e) {
76980       {
76981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76982       };
76983     } catch (...) {
76984       {
76985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76986       };
76987     }
76988   }
76989
76990 }
76991
76992
76993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
76994   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76995   Dali::Toolkit::ItemContainer *arg2 = 0 ;
76996   float arg3 ;
76997
76998   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76999   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
77000   if (!arg2) {
77001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
77002     return ;
77003   }
77004   arg3 = (float)jarg3;
77005   {
77006     try {
77007       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
77008     } catch (std::out_of_range& e) {
77009       {
77010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77011       };
77012     } catch (std::exception& e) {
77013       {
77014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77015       };
77016     } catch (Dali::DaliException e) {
77017       {
77018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77019       };
77020     } catch (...) {
77021       {
77022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77023       };
77024     }
77025   }
77026
77027 }
77028
77029
77030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
77031   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77032   Dali::Vector3 *arg2 = 0 ;
77033
77034   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77035   arg2 = (Dali::Vector3 *)jarg2;
77036   if (!arg2) {
77037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77038     return ;
77039   }
77040   {
77041     try {
77042       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
77043     } catch (std::out_of_range& e) {
77044       {
77045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77046       };
77047     } catch (std::exception& e) {
77048       {
77049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77050       };
77051     } catch (Dali::DaliException e) {
77052       {
77053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77054       };
77055     } catch (...) {
77056       {
77057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77058       };
77059     }
77060   }
77061
77062 }
77063
77064
77065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
77066   void * jresult ;
77067   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77068   Dali::Vector3 result;
77069
77070   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77071   {
77072     try {
77073       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
77074     } catch (std::out_of_range& e) {
77075       {
77076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77077       };
77078     } catch (std::exception& e) {
77079       {
77080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77081       };
77082     } catch (Dali::DaliException e) {
77083       {
77084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77085       };
77086     } catch (...) {
77087       {
77088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77089       };
77090     }
77091   }
77092
77093   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77094   return jresult;
77095 }
77096
77097
77098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
77099   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77100   Dali::Vector3 *arg2 = 0 ;
77101
77102   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77103   arg2 = (Dali::Vector3 *)jarg2;
77104   if (!arg2) {
77105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77106     return ;
77107   }
77108   {
77109     try {
77110       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
77111     } catch (std::out_of_range& e) {
77112       {
77113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77114       };
77115     } catch (std::exception& e) {
77116       {
77117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77118       };
77119     } catch (Dali::DaliException e) {
77120       {
77121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77122       };
77123     } catch (...) {
77124       {
77125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77126       };
77127     }
77128   }
77129
77130 }
77131
77132
77133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
77134   void * jresult ;
77135   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77136   Dali::Vector3 result;
77137
77138   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77139   {
77140     try {
77141       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
77142     } catch (std::out_of_range& e) {
77143       {
77144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77145       };
77146     } catch (std::exception& e) {
77147       {
77148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77149       };
77150     } catch (Dali::DaliException e) {
77151       {
77152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77153       };
77154     } catch (...) {
77155       {
77156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77157       };
77158     }
77159   }
77160
77161   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77162   return jresult;
77163 }
77164
77165
77166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
77167   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77168   Dali::Toolkit::ItemRange *arg2 = 0 ;
77169
77170   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77171   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
77172   if (!arg2) {
77173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
77174     return ;
77175   }
77176   {
77177     try {
77178       (arg1)->GetItemsRange(*arg2);
77179     } catch (std::out_of_range& e) {
77180       {
77181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77182       };
77183     } catch (std::exception& e) {
77184       {
77185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77186       };
77187     } catch (Dali::DaliException e) {
77188       {
77189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77190       };
77191     } catch (...) {
77192       {
77193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77194       };
77195     }
77196   }
77197
77198 }
77199
77200
77201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
77202   void * jresult ;
77203   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77204   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
77205
77206   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77207   {
77208     try {
77209       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
77210     } catch (std::out_of_range& e) {
77211       {
77212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77213       };
77214     } catch (std::exception& e) {
77215       {
77216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77217       };
77218     } catch (Dali::DaliException e) {
77219       {
77220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77221       };
77222     } catch (...) {
77223       {
77224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77225       };
77226     }
77227   }
77228
77229   jresult = (void *)result;
77230   return jresult;
77231 }
77232
77233
77234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
77235   Dali::Vector3 *arg1 = 0 ;
77236   PropertyInputContainer *arg2 = 0 ;
77237
77238   arg1 = (Dali::Vector3 *)jarg1;
77239   if (!arg1) {
77240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77241     return ;
77242   }
77243   arg2 = (PropertyInputContainer *)jarg2;
77244   if (!arg2) {
77245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77246     return ;
77247   }
77248   {
77249     try {
77250       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77251     } catch (std::out_of_range& e) {
77252       {
77253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77254       };
77255     } catch (std::exception& e) {
77256       {
77257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77258       };
77259     } catch (Dali::DaliException e) {
77260       {
77261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77262       };
77263     } catch (...) {
77264       {
77265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77266       };
77267     }
77268   }
77269
77270 }
77271
77272
77273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
77274   Dali::Vector3 *arg1 = 0 ;
77275   PropertyInputContainer *arg2 = 0 ;
77276
77277   arg1 = (Dali::Vector3 *)jarg1;
77278   if (!arg1) {
77279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77280     return ;
77281   }
77282   arg2 = (PropertyInputContainer *)jarg2;
77283   if (!arg2) {
77284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77285     return ;
77286   }
77287   {
77288     try {
77289       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77290     } catch (std::out_of_range& e) {
77291       {
77292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77293       };
77294     } catch (std::exception& e) {
77295       {
77296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77297       };
77298     } catch (Dali::DaliException e) {
77299       {
77300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77301       };
77302     } catch (...) {
77303       {
77304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77305       };
77306     }
77307   }
77308
77309 }
77310
77311
77312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
77313   void * jresult ;
77314   Dali::Toolkit::ScrollViewEffect *result = 0 ;
77315
77316   {
77317     try {
77318       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
77319     } catch (std::out_of_range& e) {
77320       {
77321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77322       };
77323     } catch (std::exception& e) {
77324       {
77325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77326       };
77327     } catch (Dali::DaliException e) {
77328       {
77329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77330       };
77331     } catch (...) {
77332       {
77333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77334       };
77335     }
77336   }
77337
77338   jresult = (void *)result;
77339   return jresult;
77340 }
77341
77342
77343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
77344   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
77345
77346   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
77347   {
77348     try {
77349       delete arg1;
77350     } catch (std::out_of_range& e) {
77351       {
77352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77353       };
77354     } catch (std::exception& e) {
77355       {
77356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77357       };
77358     } catch (Dali::DaliException e) {
77359       {
77360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77361       };
77362     } catch (...) {
77363       {
77364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77365       };
77366     }
77367   }
77368
77369 }
77370
77371
77372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
77373   void * jresult ;
77374   Dali::Path arg1 ;
77375   Dali::Vector3 *arg2 = 0 ;
77376   Dali::Property::Index arg3 ;
77377   Dali::Vector3 *arg4 = 0 ;
77378   unsigned int arg5 ;
77379   Dali::Path *argp1 ;
77380   Dali::Toolkit::ScrollViewPagePathEffect result;
77381
77382   argp1 = (Dali::Path *)jarg1;
77383   if (!argp1) {
77384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
77385     return 0;
77386   }
77387   arg1 = *argp1;
77388   arg2 = (Dali::Vector3 *)jarg2;
77389   if (!arg2) {
77390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77391     return 0;
77392   }
77393   arg3 = (Dali::Property::Index)jarg3;
77394   arg4 = (Dali::Vector3 *)jarg4;
77395   if (!arg4) {
77396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77397     return 0;
77398   }
77399   arg5 = (unsigned int)jarg5;
77400   {
77401     try {
77402       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
77403     } catch (std::out_of_range& e) {
77404       {
77405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77406       };
77407     } catch (std::exception& e) {
77408       {
77409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77410       };
77411     } catch (Dali::DaliException e) {
77412       {
77413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77414       };
77415     } catch (...) {
77416       {
77417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77418       };
77419     }
77420   }
77421
77422   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77423   return jresult;
77424 }
77425
77426
77427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
77428   void * jresult ;
77429   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
77430
77431   {
77432     try {
77433       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
77434     } catch (std::out_of_range& e) {
77435       {
77436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77437       };
77438     } catch (std::exception& e) {
77439       {
77440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77441       };
77442     } catch (Dali::DaliException e) {
77443       {
77444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77445       };
77446     } catch (...) {
77447       {
77448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77449       };
77450     }
77451   }
77452
77453   jresult = (void *)result;
77454   return jresult;
77455 }
77456
77457
77458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
77459   void * jresult ;
77460   Dali::BaseHandle arg1 ;
77461   Dali::BaseHandle *argp1 ;
77462   Dali::Toolkit::ScrollViewPagePathEffect result;
77463
77464   argp1 = (Dali::BaseHandle *)jarg1;
77465   if (!argp1) {
77466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77467     return 0;
77468   }
77469   arg1 = *argp1;
77470   {
77471     try {
77472       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
77473     } catch (std::out_of_range& e) {
77474       {
77475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77476       };
77477     } catch (std::exception& e) {
77478       {
77479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77480       };
77481     } catch (Dali::DaliException e) {
77482       {
77483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77484       };
77485     } catch (...) {
77486       {
77487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77488       };
77489     }
77490   }
77491
77492   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77493   return jresult;
77494 }
77495
77496
77497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
77498   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
77499   Dali::Actor arg2 ;
77500   unsigned int arg3 ;
77501   Dali::Actor *argp2 ;
77502
77503   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
77504   argp2 = (Dali::Actor *)jarg2;
77505   if (!argp2) {
77506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77507     return ;
77508   }
77509   arg2 = *argp2;
77510   arg3 = (unsigned int)jarg3;
77511   {
77512     try {
77513       (arg1)->ApplyToPage(arg2,arg3);
77514     } catch (std::out_of_range& e) {
77515       {
77516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77517       };
77518     } catch (std::exception& e) {
77519       {
77520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77521       };
77522     } catch (Dali::DaliException e) {
77523       {
77524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77525       };
77526     } catch (...) {
77527       {
77528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77529       };
77530     }
77531   }
77532
77533 }
77534
77535
77536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
77537   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
77538
77539   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
77540   {
77541     try {
77542       delete arg1;
77543     } catch (std::out_of_range& e) {
77544       {
77545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77546       };
77547     } catch (std::exception& e) {
77548       {
77549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77550       };
77551     } catch (Dali::DaliException e) {
77552       {
77553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77554       };
77555     } catch (...) {
77556       {
77557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77558       };
77559     }
77560   }
77561
77562 }
77563
77564
77565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
77566   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77567   Dali::Toolkit::ClampState arg2 ;
77568
77569   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77570   arg2 = (Dali::Toolkit::ClampState)jarg2;
77571   if (arg1) (arg1)->x = arg2;
77572 }
77573
77574
77575 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
77576   int jresult ;
77577   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77578   Dali::Toolkit::ClampState result;
77579
77580   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77581   result = (Dali::Toolkit::ClampState) ((arg1)->x);
77582   jresult = (int)result;
77583   return jresult;
77584 }
77585
77586
77587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
77588   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77589   Dali::Toolkit::ClampState arg2 ;
77590
77591   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77592   arg2 = (Dali::Toolkit::ClampState)jarg2;
77593   if (arg1) (arg1)->y = arg2;
77594 }
77595
77596
77597 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
77598   int jresult ;
77599   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77600   Dali::Toolkit::ClampState result;
77601
77602   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77603   result = (Dali::Toolkit::ClampState) ((arg1)->y);
77604   jresult = (int)result;
77605   return jresult;
77606 }
77607
77608
77609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
77610   void * jresult ;
77611   Dali::Toolkit::ClampState2D *result = 0 ;
77612
77613   {
77614     try {
77615       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
77616     } catch (std::out_of_range& e) {
77617       {
77618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77619       };
77620     } catch (std::exception& e) {
77621       {
77622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77623       };
77624     } catch (Dali::DaliException e) {
77625       {
77626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77627       };
77628     } catch (...) {
77629       {
77630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77631       };
77632     }
77633   }
77634
77635   jresult = (void *)result;
77636   return jresult;
77637 }
77638
77639
77640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
77641   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77642
77643   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77644   {
77645     try {
77646       delete arg1;
77647     } catch (std::out_of_range& e) {
77648       {
77649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77650       };
77651     } catch (std::exception& e) {
77652       {
77653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77654       };
77655     } catch (Dali::DaliException e) {
77656       {
77657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77658       };
77659     } catch (...) {
77660       {
77661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77662       };
77663     }
77664   }
77665
77666 }
77667
77668
77669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
77670   void * jresult ;
77671   float arg1 ;
77672   float arg2 ;
77673   bool arg3 ;
77674   Dali::Toolkit::RulerDomain *result = 0 ;
77675
77676   arg1 = (float)jarg1;
77677   arg2 = (float)jarg2;
77678   arg3 = jarg3 ? true : false;
77679   {
77680     try {
77681       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
77682     } catch (std::out_of_range& e) {
77683       {
77684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77685       };
77686     } catch (std::exception& e) {
77687       {
77688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77689       };
77690     } catch (Dali::DaliException e) {
77691       {
77692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77693       };
77694     } catch (...) {
77695       {
77696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77697       };
77698     }
77699   }
77700
77701   jresult = (void *)result;
77702   return jresult;
77703 }
77704
77705
77706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
77707   void * jresult ;
77708   float arg1 ;
77709   float arg2 ;
77710   Dali::Toolkit::RulerDomain *result = 0 ;
77711
77712   arg1 = (float)jarg1;
77713   arg2 = (float)jarg2;
77714   {
77715     try {
77716       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
77717     } catch (std::out_of_range& e) {
77718       {
77719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77720       };
77721     } catch (std::exception& e) {
77722       {
77723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77724       };
77725     } catch (Dali::DaliException e) {
77726       {
77727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77728       };
77729     } catch (...) {
77730       {
77731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77732       };
77733     }
77734   }
77735
77736   jresult = (void *)result;
77737   return jresult;
77738 }
77739
77740
77741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
77742   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77743   float arg2 ;
77744
77745   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77746   arg2 = (float)jarg2;
77747   if (arg1) (arg1)->min = arg2;
77748 }
77749
77750
77751 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
77752   float jresult ;
77753   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77754   float result;
77755
77756   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77757   result = (float) ((arg1)->min);
77758   jresult = result;
77759   return jresult;
77760 }
77761
77762
77763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
77764   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77765   float arg2 ;
77766
77767   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77768   arg2 = (float)jarg2;
77769   if (arg1) (arg1)->max = arg2;
77770 }
77771
77772
77773 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
77774   float jresult ;
77775   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77776   float result;
77777
77778   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77779   result = (float) ((arg1)->max);
77780   jresult = result;
77781   return jresult;
77782 }
77783
77784
77785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
77786   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77787   bool arg2 ;
77788
77789   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77790   arg2 = jarg2 ? true : false;
77791   if (arg1) (arg1)->enabled = arg2;
77792 }
77793
77794
77795 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
77796   unsigned int jresult ;
77797   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77798   bool result;
77799
77800   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77801   result = (bool) ((arg1)->enabled);
77802   jresult = result;
77803   return jresult;
77804 }
77805
77806
77807 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
77808   float jresult ;
77809   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77810   float arg2 ;
77811   float arg3 ;
77812   float arg4 ;
77813   float result;
77814
77815   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77816   arg2 = (float)jarg2;
77817   arg3 = (float)jarg3;
77818   arg4 = (float)jarg4;
77819   {
77820     try {
77821       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
77822     } catch (std::out_of_range& e) {
77823       {
77824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77825       };
77826     } catch (std::exception& e) {
77827       {
77828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77829       };
77830     } catch (Dali::DaliException e) {
77831       {
77832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77833       };
77834     } catch (...) {
77835       {
77836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77837       };
77838     }
77839   }
77840
77841   jresult = result;
77842   return jresult;
77843 }
77844
77845
77846 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
77847   float jresult ;
77848   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77849   float arg2 ;
77850   float arg3 ;
77851   float result;
77852
77853   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77854   arg2 = (float)jarg2;
77855   arg3 = (float)jarg3;
77856   {
77857     try {
77858       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
77859     } catch (std::out_of_range& e) {
77860       {
77861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77862       };
77863     } catch (std::exception& e) {
77864       {
77865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77866       };
77867     } catch (Dali::DaliException e) {
77868       {
77869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77870       };
77871     } catch (...) {
77872       {
77873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77874       };
77875     }
77876   }
77877
77878   jresult = result;
77879   return jresult;
77880 }
77881
77882
77883 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
77884   float jresult ;
77885   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77886   float arg2 ;
77887   float result;
77888
77889   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77890   arg2 = (float)jarg2;
77891   {
77892     try {
77893       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
77894     } catch (std::out_of_range& e) {
77895       {
77896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77897       };
77898     } catch (std::exception& e) {
77899       {
77900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77901       };
77902     } catch (Dali::DaliException e) {
77903       {
77904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77905       };
77906     } catch (...) {
77907       {
77908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77909       };
77910     }
77911   }
77912
77913   jresult = result;
77914   return jresult;
77915 }
77916
77917
77918 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
77919   float jresult ;
77920   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77921   float arg2 ;
77922   float arg3 ;
77923   float arg4 ;
77924   Dali::Toolkit::ClampState *arg5 = 0 ;
77925   float result;
77926
77927   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77928   arg2 = (float)jarg2;
77929   arg3 = (float)jarg3;
77930   arg4 = (float)jarg4;
77931   arg5 = (Dali::Toolkit::ClampState *)jarg5;
77932   if (!arg5) {
77933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
77934     return 0;
77935   }
77936   {
77937     try {
77938       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
77939     } catch (std::out_of_range& e) {
77940       {
77941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77942       };
77943     } catch (std::exception& e) {
77944       {
77945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77946       };
77947     } catch (Dali::DaliException e) {
77948       {
77949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77950       };
77951     } catch (...) {
77952       {
77953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77954       };
77955     }
77956   }
77957
77958   jresult = result;
77959   return jresult;
77960 }
77961
77962
77963 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
77964   float jresult ;
77965   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77966   float result;
77967
77968   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77969   {
77970     try {
77971       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
77972     } catch (std::out_of_range& e) {
77973       {
77974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77975       };
77976     } catch (std::exception& e) {
77977       {
77978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77979       };
77980     } catch (Dali::DaliException e) {
77981       {
77982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77983       };
77984     } catch (...) {
77985       {
77986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77987       };
77988     }
77989   }
77990
77991   jresult = result;
77992   return jresult;
77993 }
77994
77995
77996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
77997   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77998
77999   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78000   {
78001     try {
78002       delete arg1;
78003     } catch (std::out_of_range& e) {
78004       {
78005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78006       };
78007     } catch (std::exception& e) {
78008       {
78009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78010       };
78011     } catch (Dali::DaliException e) {
78012       {
78013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78014       };
78015     } catch (...) {
78016       {
78017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78018       };
78019     }
78020   }
78021
78022 }
78023
78024
78025 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
78026   float jresult ;
78027   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78028   float arg2 ;
78029   float arg3 ;
78030   float result;
78031
78032   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78033   arg2 = (float)jarg2;
78034   arg3 = (float)jarg3;
78035   {
78036     try {
78037       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
78038     } catch (std::out_of_range& e) {
78039       {
78040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78041       };
78042     } catch (std::exception& e) {
78043       {
78044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78045       };
78046     } catch (Dali::DaliException e) {
78047       {
78048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78049       };
78050     } catch (...) {
78051       {
78052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78053       };
78054     }
78055   }
78056
78057   jresult = result;
78058   return jresult;
78059 }
78060
78061
78062 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
78063   float jresult ;
78064   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78065   float arg2 ;
78066   float result;
78067
78068   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78069   arg2 = (float)jarg2;
78070   {
78071     try {
78072       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
78073     } catch (std::out_of_range& e) {
78074       {
78075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78076       };
78077     } catch (std::exception& e) {
78078       {
78079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78080       };
78081     } catch (Dali::DaliException e) {
78082       {
78083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78084       };
78085     } catch (...) {
78086       {
78087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78088       };
78089     }
78090   }
78091
78092   jresult = result;
78093   return jresult;
78094 }
78095
78096
78097 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78098   float jresult ;
78099   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78100   unsigned int arg2 ;
78101   unsigned int *arg3 = 0 ;
78102   bool arg4 ;
78103   float result;
78104
78105   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78106   arg2 = (unsigned int)jarg2;
78107   arg3 = (unsigned int *)jarg3;
78108   arg4 = jarg4 ? true : false;
78109   {
78110     try {
78111       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78112     } catch (std::out_of_range& e) {
78113       {
78114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78115       };
78116     } catch (std::exception& e) {
78117       {
78118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78119       };
78120     } catch (Dali::DaliException e) {
78121       {
78122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78123       };
78124     } catch (...) {
78125       {
78126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78127       };
78128     }
78129   }
78130
78131   jresult = result;
78132   return jresult;
78133 }
78134
78135
78136 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78137   unsigned int jresult ;
78138   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78139   float arg2 ;
78140   bool arg3 ;
78141   unsigned int result;
78142
78143   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78144   arg2 = (float)jarg2;
78145   arg3 = jarg3 ? true : false;
78146   {
78147     try {
78148       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
78149     } catch (std::out_of_range& e) {
78150       {
78151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78152       };
78153     } catch (std::exception& e) {
78154       {
78155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78156       };
78157     } catch (Dali::DaliException e) {
78158       {
78159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78160       };
78161     } catch (...) {
78162       {
78163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78164       };
78165     }
78166   }
78167
78168   jresult = result;
78169   return jresult;
78170 }
78171
78172
78173 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
78174   unsigned int jresult ;
78175   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78176   unsigned int result;
78177
78178   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78179   {
78180     try {
78181       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
78182     } catch (std::out_of_range& e) {
78183       {
78184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78185       };
78186     } catch (std::exception& e) {
78187       {
78188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78189       };
78190     } catch (Dali::DaliException e) {
78191       {
78192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78193       };
78194     } catch (...) {
78195       {
78196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78197       };
78198     }
78199   }
78200
78201   jresult = result;
78202   return jresult;
78203 }
78204
78205
78206 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
78207   int jresult ;
78208   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78209   Dali::Toolkit::Ruler::RulerType result;
78210
78211   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78212   {
78213     try {
78214       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
78215     } catch (std::out_of_range& e) {
78216       {
78217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78218       };
78219     } catch (std::exception& e) {
78220       {
78221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78222       };
78223     } catch (Dali::DaliException e) {
78224       {
78225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78226       };
78227     } catch (...) {
78228       {
78229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78230       };
78231     }
78232   }
78233
78234   jresult = (int)result;
78235   return jresult;
78236 }
78237
78238
78239 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
78240   unsigned int jresult ;
78241   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78242   bool result;
78243
78244   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78245   {
78246     try {
78247       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
78248     } catch (std::out_of_range& e) {
78249       {
78250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78251       };
78252     } catch (std::exception& e) {
78253       {
78254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78255       };
78256     } catch (Dali::DaliException e) {
78257       {
78258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78259       };
78260     } catch (...) {
78261       {
78262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78263       };
78264     }
78265   }
78266
78267   jresult = result;
78268   return jresult;
78269 }
78270
78271
78272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
78273   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78274
78275   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78276   {
78277     try {
78278       (arg1)->Enable();
78279     } catch (std::out_of_range& e) {
78280       {
78281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78282       };
78283     } catch (std::exception& e) {
78284       {
78285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78286       };
78287     } catch (Dali::DaliException e) {
78288       {
78289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78290       };
78291     } catch (...) {
78292       {
78293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78294       };
78295     }
78296   }
78297
78298 }
78299
78300
78301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
78302   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78303
78304   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78305   {
78306     try {
78307       (arg1)->Disable();
78308     } catch (std::out_of_range& e) {
78309       {
78310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78311       };
78312     } catch (std::exception& e) {
78313       {
78314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78315       };
78316     } catch (Dali::DaliException e) {
78317       {
78318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78319       };
78320     } catch (...) {
78321       {
78322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78323       };
78324     }
78325   }
78326
78327 }
78328
78329
78330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
78331   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78332   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
78333   Dali::Toolkit::RulerDomain *argp2 ;
78334
78335   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78336   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
78337   if (!argp2) {
78338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
78339     return ;
78340   }
78341   arg2 = *argp2;
78342   {
78343     try {
78344       (arg1)->SetDomain(arg2);
78345     } catch (std::out_of_range& e) {
78346       {
78347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78348       };
78349     } catch (std::exception& e) {
78350       {
78351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78352       };
78353     } catch (Dali::DaliException e) {
78354       {
78355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78356       };
78357     } catch (...) {
78358       {
78359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78360       };
78361     }
78362   }
78363
78364 }
78365
78366
78367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
78368   void * jresult ;
78369   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78370   Dali::Toolkit::RulerDomain *result = 0 ;
78371
78372   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78373   {
78374     try {
78375       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
78376     } catch (std::out_of_range& e) {
78377       {
78378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78379       };
78380     } catch (std::exception& e) {
78381       {
78382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78383       };
78384     } catch (Dali::DaliException e) {
78385       {
78386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78387       };
78388     } catch (...) {
78389       {
78390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78391       };
78392     }
78393   }
78394
78395   jresult = (void *)result;
78396   return jresult;
78397 }
78398
78399
78400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
78401   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78402
78403   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78404   {
78405     try {
78406       (arg1)->DisableDomain();
78407     } catch (std::out_of_range& e) {
78408       {
78409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78410       };
78411     } catch (std::exception& e) {
78412       {
78413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78414       };
78415     } catch (Dali::DaliException e) {
78416       {
78417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78418       };
78419     } catch (...) {
78420       {
78421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78422       };
78423     }
78424   }
78425
78426 }
78427
78428
78429 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
78430   float jresult ;
78431   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78432   float arg2 ;
78433   float arg3 ;
78434   float arg4 ;
78435   float result;
78436
78437   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78438   arg2 = (float)jarg2;
78439   arg3 = (float)jarg3;
78440   arg4 = (float)jarg4;
78441   {
78442     try {
78443       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
78444     } catch (std::out_of_range& e) {
78445       {
78446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78447       };
78448     } catch (std::exception& e) {
78449       {
78450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78451       };
78452     } catch (Dali::DaliException e) {
78453       {
78454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78455       };
78456     } catch (...) {
78457       {
78458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78459       };
78460     }
78461   }
78462
78463   jresult = result;
78464   return jresult;
78465 }
78466
78467
78468 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
78469   float jresult ;
78470   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78471   float arg2 ;
78472   float arg3 ;
78473   float result;
78474
78475   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78476   arg2 = (float)jarg2;
78477   arg3 = (float)jarg3;
78478   {
78479     try {
78480       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
78481     } catch (std::out_of_range& e) {
78482       {
78483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78484       };
78485     } catch (std::exception& e) {
78486       {
78487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78488       };
78489     } catch (Dali::DaliException e) {
78490       {
78491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78492       };
78493     } catch (...) {
78494       {
78495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78496       };
78497     }
78498   }
78499
78500   jresult = result;
78501   return jresult;
78502 }
78503
78504
78505 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
78506   float jresult ;
78507   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78508   float arg2 ;
78509   float result;
78510
78511   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78512   arg2 = (float)jarg2;
78513   {
78514     try {
78515       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
78516     } catch (std::out_of_range& e) {
78517       {
78518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78519       };
78520     } catch (std::exception& e) {
78521       {
78522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78523       };
78524     } catch (Dali::DaliException e) {
78525       {
78526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78527       };
78528     } catch (...) {
78529       {
78530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78531       };
78532     }
78533   }
78534
78535   jresult = result;
78536   return jresult;
78537 }
78538
78539
78540 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
78541   float jresult ;
78542   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78543   float arg2 ;
78544   float arg3 ;
78545   float arg4 ;
78546   Dali::Toolkit::ClampState *arg5 = 0 ;
78547   float result;
78548
78549   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78550   arg2 = (float)jarg2;
78551   arg3 = (float)jarg3;
78552   arg4 = (float)jarg4;
78553   arg5 = (Dali::Toolkit::ClampState *)jarg5;
78554   if (!arg5) {
78555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78556     return 0;
78557   }
78558   {
78559     try {
78560       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
78561     } catch (std::out_of_range& e) {
78562       {
78563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78564       };
78565     } catch (std::exception& e) {
78566       {
78567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78568       };
78569     } catch (Dali::DaliException e) {
78570       {
78571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78572       };
78573     } catch (...) {
78574       {
78575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78576       };
78577     }
78578   }
78579
78580   jresult = result;
78581   return jresult;
78582 }
78583
78584
78585 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
78586   float jresult ;
78587   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78588   float arg2 ;
78589   float arg3 ;
78590   float arg4 ;
78591   float arg5 ;
78592   float result;
78593
78594   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78595   arg2 = (float)jarg2;
78596   arg3 = (float)jarg3;
78597   arg4 = (float)jarg4;
78598   arg5 = (float)jarg5;
78599   {
78600     try {
78601       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
78602     } catch (std::out_of_range& e) {
78603       {
78604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78605       };
78606     } catch (std::exception& e) {
78607       {
78608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78609       };
78610     } catch (Dali::DaliException e) {
78611       {
78612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78613       };
78614     } catch (...) {
78615       {
78616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78617       };
78618     }
78619   }
78620
78621   jresult = result;
78622   return jresult;
78623 }
78624
78625
78626 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
78627   float jresult ;
78628   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78629   float arg2 ;
78630   float arg3 ;
78631   float arg4 ;
78632   float result;
78633
78634   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78635   arg2 = (float)jarg2;
78636   arg3 = (float)jarg3;
78637   arg4 = (float)jarg4;
78638   {
78639     try {
78640       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
78641     } catch (std::out_of_range& e) {
78642       {
78643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78644       };
78645     } catch (std::exception& e) {
78646       {
78647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78648       };
78649     } catch (Dali::DaliException e) {
78650       {
78651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78652       };
78653     } catch (...) {
78654       {
78655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78656       };
78657     }
78658   }
78659
78660   jresult = result;
78661   return jresult;
78662 }
78663
78664
78665 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
78666   float jresult ;
78667   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78668   float arg2 ;
78669   float arg3 ;
78670   float result;
78671
78672   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78673   arg2 = (float)jarg2;
78674   arg3 = (float)jarg3;
78675   {
78676     try {
78677       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
78678     } catch (std::out_of_range& e) {
78679       {
78680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78681       };
78682     } catch (std::exception& e) {
78683       {
78684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78685       };
78686     } catch (Dali::DaliException e) {
78687       {
78688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78689       };
78690     } catch (...) {
78691       {
78692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78693       };
78694     }
78695   }
78696
78697   jresult = result;
78698   return jresult;
78699 }
78700
78701
78702 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
78703   float jresult ;
78704   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78705   float arg2 ;
78706   float result;
78707
78708   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78709   arg2 = (float)jarg2;
78710   {
78711     try {
78712       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
78713     } catch (std::out_of_range& e) {
78714       {
78715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78716       };
78717     } catch (std::exception& e) {
78718       {
78719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78720       };
78721     } catch (Dali::DaliException e) {
78722       {
78723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78724       };
78725     } catch (...) {
78726       {
78727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78728       };
78729     }
78730   }
78731
78732   jresult = result;
78733   return jresult;
78734 }
78735
78736
78737 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
78738   float jresult ;
78739   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78740   float arg2 ;
78741   float arg3 ;
78742   float arg4 ;
78743   float arg5 ;
78744   Dali::Toolkit::ClampState *arg6 = 0 ;
78745   float result;
78746
78747   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78748   arg2 = (float)jarg2;
78749   arg3 = (float)jarg3;
78750   arg4 = (float)jarg4;
78751   arg5 = (float)jarg5;
78752   arg6 = (Dali::Toolkit::ClampState *)jarg6;
78753   if (!arg6) {
78754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78755     return 0;
78756   }
78757   {
78758     try {
78759       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
78760     } catch (std::out_of_range& e) {
78761       {
78762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78763       };
78764     } catch (std::exception& e) {
78765       {
78766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78767       };
78768     } catch (Dali::DaliException e) {
78769       {
78770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78771       };
78772     } catch (...) {
78773       {
78774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78775       };
78776     }
78777   }
78778
78779   jresult = result;
78780   return jresult;
78781 }
78782
78783
78784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
78785   void * jresult ;
78786   Dali::Toolkit::DefaultRuler *result = 0 ;
78787
78788   {
78789     try {
78790       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
78791     } catch (std::out_of_range& e) {
78792       {
78793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78794       };
78795     } catch (std::exception& e) {
78796       {
78797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78798       };
78799     } catch (Dali::DaliException e) {
78800       {
78801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78802       };
78803     } catch (...) {
78804       {
78805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78806       };
78807     }
78808   }
78809
78810   jresult = (void *)result;
78811   return jresult;
78812 }
78813
78814
78815 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
78816   float jresult ;
78817   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78818   float arg2 ;
78819   float arg3 ;
78820   float result;
78821
78822   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78823   arg2 = (float)jarg2;
78824   arg3 = (float)jarg3;
78825   {
78826     try {
78827       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
78828     } catch (std::out_of_range& e) {
78829       {
78830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78831       };
78832     } catch (std::exception& e) {
78833       {
78834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78835       };
78836     } catch (Dali::DaliException e) {
78837       {
78838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78839       };
78840     } catch (...) {
78841       {
78842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78843       };
78844     }
78845   }
78846
78847   jresult = result;
78848   return jresult;
78849 }
78850
78851
78852 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78853   float jresult ;
78854   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78855   unsigned int arg2 ;
78856   unsigned int *arg3 = 0 ;
78857   bool arg4 ;
78858   float result;
78859
78860   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78861   arg2 = (unsigned int)jarg2;
78862   arg3 = (unsigned int *)jarg3;
78863   arg4 = jarg4 ? true : false;
78864   {
78865     try {
78866       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78867     } catch (std::out_of_range& e) {
78868       {
78869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78870       };
78871     } catch (std::exception& e) {
78872       {
78873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78874       };
78875     } catch (Dali::DaliException e) {
78876       {
78877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78878       };
78879     } catch (...) {
78880       {
78881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78882       };
78883     }
78884   }
78885
78886   jresult = result;
78887   return jresult;
78888 }
78889
78890
78891 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78892   unsigned int jresult ;
78893   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78894   float arg2 ;
78895   bool arg3 ;
78896   unsigned int result;
78897
78898   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78899   arg2 = (float)jarg2;
78900   arg3 = jarg3 ? true : false;
78901   {
78902     try {
78903       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
78904     } catch (std::out_of_range& e) {
78905       {
78906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78907       };
78908     } catch (std::exception& e) {
78909       {
78910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78911       };
78912     } catch (Dali::DaliException e) {
78913       {
78914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78915       };
78916     } catch (...) {
78917       {
78918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78919       };
78920     }
78921   }
78922
78923   jresult = result;
78924   return jresult;
78925 }
78926
78927
78928 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
78929   unsigned int jresult ;
78930   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78931   unsigned int result;
78932
78933   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78934   {
78935     try {
78936       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
78937     } catch (std::out_of_range& e) {
78938       {
78939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78940       };
78941     } catch (std::exception& e) {
78942       {
78943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78944       };
78945     } catch (Dali::DaliException e) {
78946       {
78947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78948       };
78949     } catch (...) {
78950       {
78951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78952       };
78953     }
78954   }
78955
78956   jresult = result;
78957   return jresult;
78958 }
78959
78960
78961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
78962   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78963
78964   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78965   {
78966     try {
78967       delete arg1;
78968     } catch (std::out_of_range& e) {
78969       {
78970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78971       };
78972     } catch (std::exception& e) {
78973       {
78974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78975       };
78976     } catch (Dali::DaliException e) {
78977       {
78978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78979       };
78980     } catch (...) {
78981       {
78982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78983       };
78984     }
78985   }
78986
78987 }
78988
78989
78990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
78991   void * jresult ;
78992   float arg1 ;
78993   Dali::Toolkit::FixedRuler *result = 0 ;
78994
78995   arg1 = (float)jarg1;
78996   {
78997     try {
78998       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
78999     } catch (std::out_of_range& e) {
79000       {
79001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79002       };
79003     } catch (std::exception& e) {
79004       {
79005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79006       };
79007     } catch (Dali::DaliException e) {
79008       {
79009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79010       };
79011     } catch (...) {
79012       {
79013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79014       };
79015     }
79016   }
79017
79018   jresult = (void *)result;
79019   return jresult;
79020 }
79021
79022
79023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
79024   void * jresult ;
79025   Dali::Toolkit::FixedRuler *result = 0 ;
79026
79027   {
79028     try {
79029       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
79030     } catch (std::out_of_range& e) {
79031       {
79032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79033       };
79034     } catch (std::exception& e) {
79035       {
79036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79037       };
79038     } catch (Dali::DaliException e) {
79039       {
79040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79041       };
79042     } catch (...) {
79043       {
79044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79045       };
79046     }
79047   }
79048
79049   jresult = (void *)result;
79050   return jresult;
79051 }
79052
79053
79054 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
79055   float jresult ;
79056   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79057   float arg2 ;
79058   float arg3 ;
79059   float result;
79060
79061   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79062   arg2 = (float)jarg2;
79063   arg3 = (float)jarg3;
79064   {
79065     try {
79066       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
79067     } catch (std::out_of_range& e) {
79068       {
79069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79070       };
79071     } catch (std::exception& e) {
79072       {
79073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79074       };
79075     } catch (Dali::DaliException e) {
79076       {
79077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79078       };
79079     } catch (...) {
79080       {
79081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79082       };
79083     }
79084   }
79085
79086   jresult = result;
79087   return jresult;
79088 }
79089
79090
79091 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
79092   float jresult ;
79093   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79094   unsigned int arg2 ;
79095   unsigned int *arg3 = 0 ;
79096   bool arg4 ;
79097   float result;
79098
79099   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79100   arg2 = (unsigned int)jarg2;
79101   arg3 = (unsigned int *)jarg3;
79102   arg4 = jarg4 ? true : false;
79103   {
79104     try {
79105       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
79106     } catch (std::out_of_range& e) {
79107       {
79108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79109       };
79110     } catch (std::exception& e) {
79111       {
79112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79113       };
79114     } catch (Dali::DaliException e) {
79115       {
79116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79117       };
79118     } catch (...) {
79119       {
79120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79121       };
79122     }
79123   }
79124
79125   jresult = result;
79126   return jresult;
79127 }
79128
79129
79130 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
79131   unsigned int jresult ;
79132   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79133   float arg2 ;
79134   bool arg3 ;
79135   unsigned int result;
79136
79137   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79138   arg2 = (float)jarg2;
79139   arg3 = jarg3 ? true : false;
79140   {
79141     try {
79142       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
79143     } catch (std::out_of_range& e) {
79144       {
79145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79146       };
79147     } catch (std::exception& e) {
79148       {
79149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79150       };
79151     } catch (Dali::DaliException e) {
79152       {
79153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79154       };
79155     } catch (...) {
79156       {
79157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79158       };
79159     }
79160   }
79161
79162   jresult = result;
79163   return jresult;
79164 }
79165
79166
79167 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
79168   unsigned int jresult ;
79169   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79170   unsigned int result;
79171
79172   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79173   {
79174     try {
79175       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
79176     } catch (std::out_of_range& e) {
79177       {
79178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79179       };
79180     } catch (std::exception& e) {
79181       {
79182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79183       };
79184     } catch (Dali::DaliException e) {
79185       {
79186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79187       };
79188     } catch (...) {
79189       {
79190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79191       };
79192     }
79193   }
79194
79195   jresult = result;
79196   return jresult;
79197 }
79198
79199
79200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
79201   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79202
79203   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79204   {
79205     try {
79206       delete arg1;
79207     } catch (std::out_of_range& e) {
79208       {
79209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79210       };
79211     } catch (std::exception& e) {
79212       {
79213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79214       };
79215     } catch (Dali::DaliException e) {
79216       {
79217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79218       };
79219     } catch (...) {
79220       {
79221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79222       };
79223     }
79224   }
79225
79226 }
79227
79228
79229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
79230   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79231   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79232
79233   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79234   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79235   if (arg1) (arg1)->scale = *arg2;
79236 }
79237
79238
79239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
79240   void * jresult ;
79241   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79242   Dali::Toolkit::ClampState2D *result = 0 ;
79243
79244   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79245   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
79246   jresult = (void *)result;
79247   return jresult;
79248 }
79249
79250
79251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
79252   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79253   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79254
79255   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79256   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79257   if (arg1) (arg1)->position = *arg2;
79258 }
79259
79260
79261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
79262   void * jresult ;
79263   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79264   Dali::Toolkit::ClampState2D *result = 0 ;
79265
79266   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79267   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
79268   jresult = (void *)result;
79269   return jresult;
79270 }
79271
79272
79273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
79274   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79275   Dali::Toolkit::ClampState arg2 ;
79276
79277   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79278   arg2 = (Dali::Toolkit::ClampState)jarg2;
79279   if (arg1) (arg1)->rotation = arg2;
79280 }
79281
79282
79283 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
79284   int jresult ;
79285   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79286   Dali::Toolkit::ClampState result;
79287
79288   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79289   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
79290   jresult = (int)result;
79291   return jresult;
79292 }
79293
79294
79295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
79296   void * jresult ;
79297   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
79298
79299   {
79300     try {
79301       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
79302     } catch (std::out_of_range& e) {
79303       {
79304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79305       };
79306     } catch (std::exception& e) {
79307       {
79308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79309       };
79310     } catch (Dali::DaliException e) {
79311       {
79312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79313       };
79314     } catch (...) {
79315       {
79316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79317       };
79318     }
79319   }
79320
79321   jresult = (void *)result;
79322   return jresult;
79323 }
79324
79325
79326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
79327   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79328
79329   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79330   {
79331     try {
79332       delete arg1;
79333     } catch (std::out_of_range& e) {
79334       {
79335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79336       };
79337     } catch (std::exception& e) {
79338       {
79339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79340       };
79341     } catch (Dali::DaliException e) {
79342       {
79343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79344       };
79345     } catch (...) {
79346       {
79347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79348       };
79349     }
79350   }
79351
79352 }
79353
79354
79355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
79356   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79357   Dali::Toolkit::SnapType arg2 ;
79358
79359   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79360   arg2 = (Dali::Toolkit::SnapType)jarg2;
79361   if (arg1) (arg1)->type = arg2;
79362 }
79363
79364
79365 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
79366   int jresult ;
79367   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79368   Dali::Toolkit::SnapType result;
79369
79370   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79371   result = (Dali::Toolkit::SnapType) ((arg1)->type);
79372   jresult = (int)result;
79373   return jresult;
79374 }
79375
79376
79377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
79378   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79379   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
79380
79381   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79382   arg2 = (Dali::Vector2 *)jarg2;
79383   if (arg1) (arg1)->position = *arg2;
79384 }
79385
79386
79387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
79388   void * jresult ;
79389   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79390   Dali::Vector2 *result = 0 ;
79391
79392   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79393   result = (Dali::Vector2 *)& ((arg1)->position);
79394   jresult = (void *)result;
79395   return jresult;
79396 }
79397
79398
79399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
79400   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79401   float arg2 ;
79402
79403   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79404   arg2 = (float)jarg2;
79405   if (arg1) (arg1)->duration = arg2;
79406 }
79407
79408
79409 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
79410   float jresult ;
79411   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79412   float result;
79413
79414   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79415   result = (float) ((arg1)->duration);
79416   jresult = result;
79417   return jresult;
79418 }
79419
79420
79421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
79422   void * jresult ;
79423   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
79424
79425   {
79426     try {
79427       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
79428     } catch (std::out_of_range& e) {
79429       {
79430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79431       };
79432     } catch (std::exception& e) {
79433       {
79434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79435       };
79436     } catch (Dali::DaliException e) {
79437       {
79438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79439       };
79440     } catch (...) {
79441       {
79442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79443       };
79444     }
79445   }
79446
79447   jresult = (void *)result;
79448   return jresult;
79449 }
79450
79451
79452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
79453   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79454
79455   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79456   {
79457     try {
79458       delete arg1;
79459     } catch (std::out_of_range& e) {
79460       {
79461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79462       };
79463     } catch (std::exception& e) {
79464       {
79465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79466       };
79467     } catch (Dali::DaliException e) {
79468       {
79469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79470       };
79471     } catch (...) {
79472       {
79473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79474       };
79475     }
79476   }
79477
79478 }
79479
79480
79481 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
79482   int jresult ;
79483   int result;
79484
79485   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
79486   jresult = (int)result;
79487   return jresult;
79488 }
79489
79490
79491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
79492   int jresult ;
79493   int result;
79494
79495   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
79496   jresult = (int)result;
79497   return jresult;
79498 }
79499
79500
79501 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
79502   int jresult ;
79503   int result;
79504
79505   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
79506   jresult = (int)result;
79507   return jresult;
79508 }
79509
79510
79511 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
79512   int jresult ;
79513   int result;
79514
79515   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
79516   jresult = (int)result;
79517   return jresult;
79518 }
79519
79520
79521 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
79522   int jresult ;
79523   int result;
79524
79525   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
79526   jresult = (int)result;
79527   return jresult;
79528 }
79529
79530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
79531   int jresult ;
79532   int result;
79533
79534   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
79535   jresult = (int)result;
79536   return jresult;
79537 }
79538
79539
79540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
79541   int jresult ;
79542   int result;
79543
79544   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
79545   jresult = (int)result;
79546   return jresult;
79547 }
79548
79549
79550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
79551   int jresult ;
79552   int result;
79553
79554   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
79555   jresult = (int)result;
79556   return jresult;
79557 }
79558
79559
79560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
79561   int jresult ;
79562   int result;
79563
79564   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
79565   jresult = (int)result;
79566   return jresult;
79567 }
79568
79569
79570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
79571   int jresult ;
79572   int result;
79573
79574   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
79575   jresult = (int)result;
79576   return jresult;
79577 }
79578
79579
79580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
79581   int jresult ;
79582   int result;
79583
79584   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
79585   jresult = (int)result;
79586   return jresult;
79587 }
79588
79589
79590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
79591   int jresult ;
79592   int result;
79593
79594   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
79595   jresult = (int)result;
79596   return jresult;
79597 }
79598
79599
79600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
79601   int jresult ;
79602   int result;
79603
79604   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
79605   jresult = (int)result;
79606   return jresult;
79607 }
79608
79609
79610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
79611   int jresult ;
79612   int result;
79613
79614   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
79615   jresult = (int)result;
79616   return jresult;
79617 }
79618
79619
79620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
79621   int jresult ;
79622   int result;
79623
79624   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
79625   jresult = (int)result;
79626   return jresult;
79627 }
79628
79629
79630 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
79631   int jresult ;
79632   int result;
79633
79634   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
79635   jresult = (int)result;
79636   return jresult;
79637 }
79638
79639
79640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
79641   int jresult ;
79642   int result;
79643
79644   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
79645   jresult = (int)result;
79646   return jresult;
79647 }
79648
79649
79650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
79651   int jresult ;
79652   int result;
79653
79654   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
79655   jresult = (int)result;
79656   return jresult;
79657 }
79658
79659
79660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
79661   int jresult ;
79662   int result;
79663
79664   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
79665   jresult = (int)result;
79666   return jresult;
79667 }
79668
79669
79670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
79671   int jresult ;
79672   int result;
79673
79674   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
79675   jresult = (int)result;
79676   return jresult;
79677 }
79678
79679
79680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
79681   int jresult ;
79682   int result;
79683
79684   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
79685   jresult = (int)result;
79686   return jresult;
79687 }
79688
79689
79690 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
79691   int jresult ;
79692   int result;
79693
79694   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
79695   jresult = (int)result;
79696   return jresult;
79697 }
79698
79699
79700 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
79701   int jresult ;
79702   int result;
79703
79704   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
79705   jresult = (int)result;
79706   return jresult;
79707 }
79708
79709
79710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
79711   int jresult ;
79712   int result;
79713
79714   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
79715   jresult = (int)result;
79716   return jresult;
79717 }
79718
79719
79720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
79721   int jresult ;
79722   int result;
79723
79724   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
79725   jresult = (int)result;
79726   return jresult;
79727 }
79728
79729
79730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
79731   int jresult ;
79732   int result;
79733
79734   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
79735   jresult = (int)result;
79736   return jresult;
79737 }
79738
79739
79740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
79741   void * jresult ;
79742   Dali::Toolkit::ScrollView::Property *result = 0 ;
79743
79744   {
79745     try {
79746       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
79747     } catch (std::out_of_range& e) {
79748       {
79749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79750       };
79751     } catch (std::exception& e) {
79752       {
79753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79754       };
79755     } catch (Dali::DaliException e) {
79756       {
79757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79758       };
79759     } catch (...) {
79760       {
79761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79762       };
79763     }
79764   }
79765
79766   jresult = (void *)result;
79767   return jresult;
79768 }
79769
79770
79771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
79772   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
79773
79774   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
79775   {
79776     try {
79777       delete arg1;
79778     } catch (std::out_of_range& e) {
79779       {
79780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79781       };
79782     } catch (std::exception& e) {
79783       {
79784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79785       };
79786     } catch (Dali::DaliException e) {
79787       {
79788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79789       };
79790     } catch (...) {
79791       {
79792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79793       };
79794     }
79795   }
79796
79797 }
79798
79799
79800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
79801   void * jresult ;
79802   Dali::Toolkit::ScrollView *result = 0 ;
79803
79804   {
79805     try {
79806       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
79807     } catch (std::out_of_range& e) {
79808       {
79809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79810       };
79811     } catch (std::exception& e) {
79812       {
79813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79814       };
79815     } catch (Dali::DaliException e) {
79816       {
79817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79818       };
79819     } catch (...) {
79820       {
79821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79822       };
79823     }
79824   }
79825
79826   jresult = (void *)result;
79827   return jresult;
79828 }
79829
79830
79831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
79832   void * jresult ;
79833   Dali::Toolkit::ScrollView *arg1 = 0 ;
79834   Dali::Toolkit::ScrollView *result = 0 ;
79835
79836   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79837   if (!arg1) {
79838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
79839     return 0;
79840   }
79841   {
79842     try {
79843       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
79844     } catch (std::out_of_range& e) {
79845       {
79846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79847       };
79848     } catch (std::exception& e) {
79849       {
79850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79851       };
79852     } catch (Dali::DaliException e) {
79853       {
79854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79855       };
79856     } catch (...) {
79857       {
79858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79859       };
79860     }
79861   }
79862
79863   jresult = (void *)result;
79864   return jresult;
79865 }
79866
79867
79868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
79869   void * jresult ;
79870   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79871   Dali::Toolkit::ScrollView *arg2 = 0 ;
79872   Dali::Toolkit::ScrollView *result = 0 ;
79873
79874   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79875   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
79876   if (!arg2) {
79877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
79878     return 0;
79879   }
79880   {
79881     try {
79882       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
79883     } catch (std::out_of_range& e) {
79884       {
79885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79886       };
79887     } catch (std::exception& e) {
79888       {
79889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79890       };
79891     } catch (Dali::DaliException e) {
79892       {
79893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79894       };
79895     } catch (...) {
79896       {
79897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79898       };
79899     }
79900   }
79901
79902   jresult = (void *)result;
79903   return jresult;
79904 }
79905
79906
79907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
79908   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79909
79910   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79911   {
79912     try {
79913       delete arg1;
79914     } catch (std::out_of_range& e) {
79915       {
79916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79917       };
79918     } catch (std::exception& e) {
79919       {
79920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79921       };
79922     } catch (Dali::DaliException e) {
79923       {
79924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79925       };
79926     } catch (...) {
79927       {
79928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79929       };
79930     }
79931   }
79932
79933 }
79934
79935
79936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
79937   void * jresult ;
79938   Dali::Toolkit::ScrollView result;
79939
79940   {
79941     try {
79942       result = Dali::Toolkit::ScrollView::New();
79943     } catch (std::out_of_range& e) {
79944       {
79945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79946       };
79947     } catch (std::exception& e) {
79948       {
79949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79950       };
79951     } catch (Dali::DaliException e) {
79952       {
79953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79954       };
79955     } catch (...) {
79956       {
79957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79958       };
79959     }
79960   }
79961
79962   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
79963   return jresult;
79964 }
79965
79966
79967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
79968   void * jresult ;
79969   Dali::BaseHandle arg1 ;
79970   Dali::BaseHandle *argp1 ;
79971   Dali::Toolkit::ScrollView result;
79972
79973   argp1 = (Dali::BaseHandle *)jarg1;
79974   if (!argp1) {
79975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79976     return 0;
79977   }
79978   arg1 = *argp1;
79979   {
79980     try {
79981       result = Dali::Toolkit::ScrollView::DownCast(arg1);
79982     } catch (std::out_of_range& e) {
79983       {
79984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79985       };
79986     } catch (std::exception& e) {
79987       {
79988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79989       };
79990     } catch (Dali::DaliException e) {
79991       {
79992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79993       };
79994     } catch (...) {
79995       {
79996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79997       };
79998     }
79999   }
80000
80001   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
80002   return jresult;
80003 }
80004
80005
80006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
80007   void * jresult ;
80008   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80009   Dali::AlphaFunction result;
80010
80011   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80012   {
80013     try {
80014       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
80015     } catch (std::out_of_range& e) {
80016       {
80017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80018       };
80019     } catch (std::exception& e) {
80020       {
80021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80022       };
80023     } catch (Dali::DaliException e) {
80024       {
80025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80026       };
80027     } catch (...) {
80028       {
80029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80030       };
80031     }
80032   }
80033
80034   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80035   return jresult;
80036 }
80037
80038
80039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
80040   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80041   Dali::AlphaFunction arg2 ;
80042   Dali::AlphaFunction *argp2 ;
80043
80044   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80045   argp2 = (Dali::AlphaFunction *)jarg2;
80046   if (!argp2) {
80047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80048     return ;
80049   }
80050   arg2 = *argp2;
80051   {
80052     try {
80053       (arg1)->SetScrollSnapAlphaFunction(arg2);
80054     } catch (std::out_of_range& e) {
80055       {
80056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80057       };
80058     } catch (std::exception& e) {
80059       {
80060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80061       };
80062     } catch (Dali::DaliException e) {
80063       {
80064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80065       };
80066     } catch (...) {
80067       {
80068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80069       };
80070     }
80071   }
80072
80073 }
80074
80075
80076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
80077   void * jresult ;
80078   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80079   Dali::AlphaFunction result;
80080
80081   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80082   {
80083     try {
80084       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
80085     } catch (std::out_of_range& e) {
80086       {
80087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80088       };
80089     } catch (std::exception& e) {
80090       {
80091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80092       };
80093     } catch (Dali::DaliException e) {
80094       {
80095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80096       };
80097     } catch (...) {
80098       {
80099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80100       };
80101     }
80102   }
80103
80104   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80105   return jresult;
80106 }
80107
80108
80109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
80110   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80111   Dali::AlphaFunction arg2 ;
80112   Dali::AlphaFunction *argp2 ;
80113
80114   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80115   argp2 = (Dali::AlphaFunction *)jarg2;
80116   if (!argp2) {
80117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80118     return ;
80119   }
80120   arg2 = *argp2;
80121   {
80122     try {
80123       (arg1)->SetScrollFlickAlphaFunction(arg2);
80124     } catch (std::out_of_range& e) {
80125       {
80126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80127       };
80128     } catch (std::exception& e) {
80129       {
80130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80131       };
80132     } catch (Dali::DaliException e) {
80133       {
80134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80135       };
80136     } catch (...) {
80137       {
80138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80139       };
80140     }
80141   }
80142
80143 }
80144
80145
80146 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
80147   float jresult ;
80148   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80149   float result;
80150
80151   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80152   {
80153     try {
80154       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
80155     } catch (std::out_of_range& e) {
80156       {
80157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80158       };
80159     } catch (std::exception& e) {
80160       {
80161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80162       };
80163     } catch (Dali::DaliException e) {
80164       {
80165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80166       };
80167     } catch (...) {
80168       {
80169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80170       };
80171     }
80172   }
80173
80174   jresult = result;
80175   return jresult;
80176 }
80177
80178
80179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
80180   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80181   float arg2 ;
80182
80183   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80184   arg2 = (float)jarg2;
80185   {
80186     try {
80187       (arg1)->SetScrollSnapDuration(arg2);
80188     } catch (std::out_of_range& e) {
80189       {
80190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80191       };
80192     } catch (std::exception& e) {
80193       {
80194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80195       };
80196     } catch (Dali::DaliException e) {
80197       {
80198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80199       };
80200     } catch (...) {
80201       {
80202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80203       };
80204     }
80205   }
80206
80207 }
80208
80209
80210 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
80211   float jresult ;
80212   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80213   float result;
80214
80215   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80216   {
80217     try {
80218       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
80219     } catch (std::out_of_range& e) {
80220       {
80221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80222       };
80223     } catch (std::exception& e) {
80224       {
80225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80226       };
80227     } catch (Dali::DaliException e) {
80228       {
80229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80230       };
80231     } catch (...) {
80232       {
80233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80234       };
80235     }
80236   }
80237
80238   jresult = result;
80239   return jresult;
80240 }
80241
80242
80243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
80244   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80245   float arg2 ;
80246
80247   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80248   arg2 = (float)jarg2;
80249   {
80250     try {
80251       (arg1)->SetScrollFlickDuration(arg2);
80252     } catch (std::out_of_range& e) {
80253       {
80254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80255       };
80256     } catch (std::exception& e) {
80257       {
80258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80259       };
80260     } catch (Dali::DaliException e) {
80261       {
80262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80263       };
80264     } catch (...) {
80265       {
80266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80267       };
80268     }
80269   }
80270
80271 }
80272
80273
80274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
80275   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80276   Dali::Toolkit::RulerPtr arg2 ;
80277   Dali::Toolkit::RulerPtr *argp2 ;
80278
80279   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80280   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80281   if (!argp2) {
80282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80283     return ;
80284   }
80285   arg2 = *argp2;
80286   {
80287     try {
80288       (arg1)->SetRulerX(arg2);
80289     } catch (std::out_of_range& e) {
80290       {
80291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80292       };
80293     } catch (std::exception& e) {
80294       {
80295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80296       };
80297     } catch (Dali::DaliException e) {
80298       {
80299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80300       };
80301     } catch (...) {
80302       {
80303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80304       };
80305     }
80306   }
80307
80308 }
80309
80310
80311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
80312   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80313   Dali::Toolkit::RulerPtr arg2 ;
80314   Dali::Toolkit::RulerPtr *argp2 ;
80315
80316   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80317   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80318   if (!argp2) {
80319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80320     return ;
80321   }
80322   arg2 = *argp2;
80323   {
80324     try {
80325       (arg1)->SetRulerY(arg2);
80326     } catch (std::out_of_range& e) {
80327       {
80328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80329       };
80330     } catch (std::exception& e) {
80331       {
80332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80333       };
80334     } catch (Dali::DaliException e) {
80335       {
80336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80337       };
80338     } catch (...) {
80339       {
80340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80341       };
80342     }
80343   }
80344
80345 }
80346
80347
80348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
80349   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80350   bool arg2 ;
80351
80352   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80353   arg2 = jarg2 ? true : false;
80354   {
80355     try {
80356       (arg1)->SetScrollSensitive(arg2);
80357     } catch (std::out_of_range& e) {
80358       {
80359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80360       };
80361     } catch (std::exception& e) {
80362       {
80363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80364       };
80365     } catch (Dali::DaliException e) {
80366       {
80367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80368       };
80369     } catch (...) {
80370       {
80371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80372       };
80373     }
80374   }
80375
80376 }
80377
80378
80379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
80380   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80381   float arg2 ;
80382   float arg3 ;
80383
80384   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80385   arg2 = (float)jarg2;
80386   arg3 = (float)jarg3;
80387   {
80388     try {
80389       (arg1)->SetMaxOvershoot(arg2,arg3);
80390     } catch (std::out_of_range& e) {
80391       {
80392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80393       };
80394     } catch (std::exception& e) {
80395       {
80396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80397       };
80398     } catch (Dali::DaliException e) {
80399       {
80400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80401       };
80402     } catch (...) {
80403       {
80404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80405       };
80406     }
80407   }
80408
80409 }
80410
80411
80412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
80413   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80414   Dali::AlphaFunction arg2 ;
80415   Dali::AlphaFunction *argp2 ;
80416
80417   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80418   argp2 = (Dali::AlphaFunction *)jarg2;
80419   if (!argp2) {
80420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80421     return ;
80422   }
80423   arg2 = *argp2;
80424   {
80425     try {
80426       (arg1)->SetSnapOvershootAlphaFunction(arg2);
80427     } catch (std::out_of_range& e) {
80428       {
80429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80430       };
80431     } catch (std::exception& e) {
80432       {
80433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80434       };
80435     } catch (Dali::DaliException e) {
80436       {
80437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80438       };
80439     } catch (...) {
80440       {
80441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80442       };
80443     }
80444   }
80445
80446 }
80447
80448
80449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
80450   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80451   float arg2 ;
80452
80453   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80454   arg2 = (float)jarg2;
80455   {
80456     try {
80457       (arg1)->SetSnapOvershootDuration(arg2);
80458     } catch (std::out_of_range& e) {
80459       {
80460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80461       };
80462     } catch (std::exception& e) {
80463       {
80464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80465       };
80466     } catch (Dali::DaliException e) {
80467       {
80468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80469       };
80470     } catch (...) {
80471       {
80472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80473       };
80474     }
80475   }
80476
80477 }
80478
80479
80480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
80481   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80482   bool arg2 ;
80483
80484   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80485   arg2 = jarg2 ? true : false;
80486   {
80487     try {
80488       (arg1)->SetActorAutoSnap(arg2);
80489     } catch (std::out_of_range& e) {
80490       {
80491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80492       };
80493     } catch (std::exception& e) {
80494       {
80495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80496       };
80497     } catch (Dali::DaliException e) {
80498       {
80499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80500       };
80501     } catch (...) {
80502       {
80503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80504       };
80505     }
80506   }
80507
80508 }
80509
80510
80511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
80512   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80513   bool arg2 ;
80514
80515   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80516   arg2 = jarg2 ? true : false;
80517   {
80518     try {
80519       (arg1)->SetWrapMode(arg2);
80520     } catch (std::out_of_range& e) {
80521       {
80522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80523       };
80524     } catch (std::exception& e) {
80525       {
80526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80527       };
80528     } catch (Dali::DaliException e) {
80529       {
80530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80531       };
80532     } catch (...) {
80533       {
80534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80535       };
80536     }
80537   }
80538
80539 }
80540
80541
80542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
80543   int jresult ;
80544   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80545   int result;
80546
80547   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80548   {
80549     try {
80550       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
80551     } catch (std::out_of_range& e) {
80552       {
80553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80554       };
80555     } catch (std::exception& e) {
80556       {
80557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80558       };
80559     } catch (Dali::DaliException e) {
80560       {
80561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80562       };
80563     } catch (...) {
80564       {
80565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80566       };
80567     }
80568   }
80569
80570   jresult = result;
80571   return jresult;
80572 }
80573
80574
80575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
80576   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80577   int arg2 ;
80578
80579   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80580   arg2 = (int)jarg2;
80581   {
80582     try {
80583       (arg1)->SetScrollUpdateDistance(arg2);
80584     } catch (std::out_of_range& e) {
80585       {
80586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80587       };
80588     } catch (std::exception& e) {
80589       {
80590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80591       };
80592     } catch (Dali::DaliException e) {
80593       {
80594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80595       };
80596     } catch (...) {
80597       {
80598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80599       };
80600     }
80601   }
80602
80603 }
80604
80605
80606 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
80607   unsigned int jresult ;
80608   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80609   bool result;
80610
80611   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80612   {
80613     try {
80614       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
80615     } catch (std::out_of_range& e) {
80616       {
80617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80618       };
80619     } catch (std::exception& e) {
80620       {
80621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80622       };
80623     } catch (Dali::DaliException e) {
80624       {
80625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80626       };
80627     } catch (...) {
80628       {
80629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80630       };
80631     }
80632   }
80633
80634   jresult = result;
80635   return jresult;
80636 }
80637
80638
80639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
80640   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80641   bool arg2 ;
80642
80643   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80644   arg2 = jarg2 ? true : false;
80645   {
80646     try {
80647       (arg1)->SetAxisAutoLock(arg2);
80648     } catch (std::out_of_range& e) {
80649       {
80650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80651       };
80652     } catch (std::exception& e) {
80653       {
80654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80655       };
80656     } catch (Dali::DaliException e) {
80657       {
80658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80659       };
80660     } catch (...) {
80661       {
80662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80663       };
80664     }
80665   }
80666
80667 }
80668
80669
80670 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
80671   float jresult ;
80672   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80673   float result;
80674
80675   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80676   {
80677     try {
80678       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
80679     } catch (std::out_of_range& e) {
80680       {
80681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80682       };
80683     } catch (std::exception& e) {
80684       {
80685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80686       };
80687     } catch (Dali::DaliException e) {
80688       {
80689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80690       };
80691     } catch (...) {
80692       {
80693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80694       };
80695     }
80696   }
80697
80698   jresult = result;
80699   return jresult;
80700 }
80701
80702
80703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
80704   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80705   float arg2 ;
80706
80707   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80708   arg2 = (float)jarg2;
80709   {
80710     try {
80711       (arg1)->SetAxisAutoLockGradient(arg2);
80712     } catch (std::out_of_range& e) {
80713       {
80714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80715       };
80716     } catch (std::exception& e) {
80717       {
80718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80719       };
80720     } catch (Dali::DaliException e) {
80721       {
80722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80723       };
80724     } catch (...) {
80725       {
80726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80727       };
80728     }
80729   }
80730
80731 }
80732
80733
80734 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
80735   float jresult ;
80736   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80737   float result;
80738
80739   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80740   {
80741     try {
80742       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
80743     } catch (std::out_of_range& e) {
80744       {
80745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80746       };
80747     } catch (std::exception& e) {
80748       {
80749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80750       };
80751     } catch (Dali::DaliException e) {
80752       {
80753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80754       };
80755     } catch (...) {
80756       {
80757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80758       };
80759     }
80760   }
80761
80762   jresult = result;
80763   return jresult;
80764 }
80765
80766
80767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
80768   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80769   float arg2 ;
80770
80771   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80772   arg2 = (float)jarg2;
80773   {
80774     try {
80775       (arg1)->SetFrictionCoefficient(arg2);
80776     } catch (std::out_of_range& e) {
80777       {
80778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80779       };
80780     } catch (std::exception& e) {
80781       {
80782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80783       };
80784     } catch (Dali::DaliException e) {
80785       {
80786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80787       };
80788     } catch (...) {
80789       {
80790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80791       };
80792     }
80793   }
80794
80795 }
80796
80797
80798 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
80799   float jresult ;
80800   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80801   float result;
80802
80803   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80804   {
80805     try {
80806       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
80807     } catch (std::out_of_range& e) {
80808       {
80809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80810       };
80811     } catch (std::exception& e) {
80812       {
80813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80814       };
80815     } catch (Dali::DaliException e) {
80816       {
80817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80818       };
80819     } catch (...) {
80820       {
80821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80822       };
80823     }
80824   }
80825
80826   jresult = result;
80827   return jresult;
80828 }
80829
80830
80831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
80832   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80833   float arg2 ;
80834
80835   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80836   arg2 = (float)jarg2;
80837   {
80838     try {
80839       (arg1)->SetFlickSpeedCoefficient(arg2);
80840     } catch (std::out_of_range& e) {
80841       {
80842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80843       };
80844     } catch (std::exception& e) {
80845       {
80846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80847       };
80848     } catch (Dali::DaliException e) {
80849       {
80850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80851       };
80852     } catch (...) {
80853       {
80854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80855       };
80856     }
80857   }
80858
80859 }
80860
80861
80862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
80863   void * jresult ;
80864   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80865   Dali::Vector2 result;
80866
80867   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80868   {
80869     try {
80870       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
80871     } catch (std::out_of_range& e) {
80872       {
80873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80874       };
80875     } catch (std::exception& e) {
80876       {
80877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80878       };
80879     } catch (Dali::DaliException e) {
80880       {
80881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80882       };
80883     } catch (...) {
80884       {
80885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80886       };
80887     }
80888   }
80889
80890   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80891   return jresult;
80892 }
80893
80894
80895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
80896   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80897   Dali::Vector2 *arg2 = 0 ;
80898
80899   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80900   arg2 = (Dali::Vector2 *)jarg2;
80901   if (!arg2) {
80902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80903     return ;
80904   }
80905   {
80906     try {
80907       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
80908     } catch (std::out_of_range& e) {
80909       {
80910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80911       };
80912     } catch (std::exception& e) {
80913       {
80914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80915       };
80916     } catch (Dali::DaliException e) {
80917       {
80918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80919       };
80920     } catch (...) {
80921       {
80922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80923       };
80924     }
80925   }
80926
80927 }
80928
80929
80930 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
80931   float jresult ;
80932   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80933   float result;
80934
80935   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80936   {
80937     try {
80938       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
80939     } catch (std::out_of_range& e) {
80940       {
80941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80942       };
80943     } catch (std::exception& e) {
80944       {
80945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80946       };
80947     } catch (Dali::DaliException e) {
80948       {
80949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80950       };
80951     } catch (...) {
80952       {
80953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80954       };
80955     }
80956   }
80957
80958   jresult = result;
80959   return jresult;
80960 }
80961
80962
80963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
80964   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80965   float arg2 ;
80966
80967   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80968   arg2 = (float)jarg2;
80969   {
80970     try {
80971       (arg1)->SetMinimumSpeedForFlick(arg2);
80972     } catch (std::out_of_range& e) {
80973       {
80974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80975       };
80976     } catch (std::exception& e) {
80977       {
80978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80979       };
80980     } catch (Dali::DaliException e) {
80981       {
80982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80983       };
80984     } catch (...) {
80985       {
80986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80987       };
80988     }
80989   }
80990
80991 }
80992
80993
80994 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
80995   float jresult ;
80996   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80997   float result;
80998
80999   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81000   {
81001     try {
81002       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
81003     } catch (std::out_of_range& e) {
81004       {
81005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81006       };
81007     } catch (std::exception& e) {
81008       {
81009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81010       };
81011     } catch (Dali::DaliException e) {
81012       {
81013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81014       };
81015     } catch (...) {
81016       {
81017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81018       };
81019     }
81020   }
81021
81022   jresult = result;
81023   return jresult;
81024 }
81025
81026
81027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
81028   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81029   float arg2 ;
81030
81031   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81032   arg2 = (float)jarg2;
81033   {
81034     try {
81035       (arg1)->SetMaxFlickSpeed(arg2);
81036     } catch (std::out_of_range& e) {
81037       {
81038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81039       };
81040     } catch (std::exception& e) {
81041       {
81042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81043       };
81044     } catch (Dali::DaliException e) {
81045       {
81046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81047       };
81048     } catch (...) {
81049       {
81050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81051       };
81052     }
81053   }
81054
81055 }
81056
81057
81058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
81059   void * jresult ;
81060   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81061   Dali::Vector2 result;
81062
81063   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81064   {
81065     try {
81066       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
81067     } catch (std::out_of_range& e) {
81068       {
81069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81070       };
81071     } catch (std::exception& e) {
81072       {
81073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81074       };
81075     } catch (Dali::DaliException e) {
81076       {
81077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81078       };
81079     } catch (...) {
81080       {
81081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81082       };
81083     }
81084   }
81085
81086   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81087   return jresult;
81088 }
81089
81090
81091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
81092   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81093   Dali::Vector2 arg2 ;
81094   Dali::Vector2 *argp2 ;
81095
81096   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81097   argp2 = (Dali::Vector2 *)jarg2;
81098   if (!argp2) {
81099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
81100     return ;
81101   }
81102   arg2 = *argp2;
81103   {
81104     try {
81105       (arg1)->SetWheelScrollDistanceStep(arg2);
81106     } catch (std::out_of_range& e) {
81107       {
81108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81109       };
81110     } catch (std::exception& e) {
81111       {
81112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81113       };
81114     } catch (Dali::DaliException e) {
81115       {
81116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81117       };
81118     } catch (...) {
81119       {
81120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81121       };
81122     }
81123   }
81124
81125 }
81126
81127
81128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
81129   void * jresult ;
81130   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81131   Dali::Vector2 result;
81132
81133   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81134   {
81135     try {
81136       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
81137     } catch (std::out_of_range& e) {
81138       {
81139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81140       };
81141     } catch (std::exception& e) {
81142       {
81143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81144       };
81145     } catch (Dali::DaliException e) {
81146       {
81147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81148       };
81149     } catch (...) {
81150       {
81151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81152       };
81153     }
81154   }
81155
81156   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81157   return jresult;
81158 }
81159
81160
81161 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
81162   unsigned int jresult ;
81163   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81164   unsigned int result;
81165
81166   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81167   {
81168     try {
81169       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
81170     } catch (std::out_of_range& e) {
81171       {
81172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81173       };
81174     } catch (std::exception& e) {
81175       {
81176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81177       };
81178     } catch (Dali::DaliException e) {
81179       {
81180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81181       };
81182     } catch (...) {
81183       {
81184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81185       };
81186     }
81187   }
81188
81189   jresult = result;
81190   return jresult;
81191 }
81192
81193
81194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
81195   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81196   Dali::Vector2 *arg2 = 0 ;
81197
81198   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81199   arg2 = (Dali::Vector2 *)jarg2;
81200   if (!arg2) {
81201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81202     return ;
81203   }
81204   {
81205     try {
81206       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
81207     } catch (std::out_of_range& e) {
81208       {
81209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81210       };
81211     } catch (std::exception& e) {
81212       {
81213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81214       };
81215     } catch (Dali::DaliException e) {
81216       {
81217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81218       };
81219     } catch (...) {
81220       {
81221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81222       };
81223     }
81224   }
81225
81226 }
81227
81228
81229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
81230   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81231   Dali::Vector2 *arg2 = 0 ;
81232   float arg3 ;
81233
81234   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81235   arg2 = (Dali::Vector2 *)jarg2;
81236   if (!arg2) {
81237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81238     return ;
81239   }
81240   arg3 = (float)jarg3;
81241   {
81242     try {
81243       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
81244     } catch (std::out_of_range& e) {
81245       {
81246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81247       };
81248     } catch (std::exception& e) {
81249       {
81250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81251       };
81252     } catch (Dali::DaliException e) {
81253       {
81254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81255       };
81256     } catch (...) {
81257       {
81258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81259       };
81260     }
81261   }
81262
81263 }
81264
81265
81266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
81267   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81268   Dali::Vector2 *arg2 = 0 ;
81269   float arg3 ;
81270   Dali::AlphaFunction arg4 ;
81271   Dali::AlphaFunction *argp4 ;
81272
81273   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81274   arg2 = (Dali::Vector2 *)jarg2;
81275   if (!arg2) {
81276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81277     return ;
81278   }
81279   arg3 = (float)jarg3;
81280   argp4 = (Dali::AlphaFunction *)jarg4;
81281   if (!argp4) {
81282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81283     return ;
81284   }
81285   arg4 = *argp4;
81286   {
81287     try {
81288       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
81289     } catch (std::out_of_range& e) {
81290       {
81291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81292       };
81293     } catch (std::exception& e) {
81294       {
81295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81296       };
81297     } catch (Dali::DaliException e) {
81298       {
81299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81300       };
81301     } catch (...) {
81302       {
81303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81304       };
81305     }
81306   }
81307
81308 }
81309
81310
81311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
81312   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81313   Dali::Vector2 *arg2 = 0 ;
81314   float arg3 ;
81315   Dali::Toolkit::DirectionBias arg4 ;
81316   Dali::Toolkit::DirectionBias arg5 ;
81317
81318   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81319   arg2 = (Dali::Vector2 *)jarg2;
81320   if (!arg2) {
81321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81322     return ;
81323   }
81324   arg3 = (float)jarg3;
81325   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81326   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81327   {
81328     try {
81329       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
81330     } catch (std::out_of_range& e) {
81331       {
81332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81333       };
81334     } catch (std::exception& e) {
81335       {
81336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81337       };
81338     } catch (Dali::DaliException e) {
81339       {
81340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81341       };
81342     } catch (...) {
81343       {
81344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81345       };
81346     }
81347   }
81348
81349 }
81350
81351
81352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
81353   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81354   Dali::Vector2 *arg2 = 0 ;
81355   float arg3 ;
81356   Dali::AlphaFunction arg4 ;
81357   Dali::Toolkit::DirectionBias arg5 ;
81358   Dali::Toolkit::DirectionBias arg6 ;
81359   Dali::AlphaFunction *argp4 ;
81360
81361   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81362   arg2 = (Dali::Vector2 *)jarg2;
81363   if (!arg2) {
81364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81365     return ;
81366   }
81367   arg3 = (float)jarg3;
81368   argp4 = (Dali::AlphaFunction *)jarg4;
81369   if (!argp4) {
81370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81371     return ;
81372   }
81373   arg4 = *argp4;
81374   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81375   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
81376   {
81377     try {
81378       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
81379     } catch (std::out_of_range& e) {
81380       {
81381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81382       };
81383     } catch (std::exception& e) {
81384       {
81385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81386       };
81387     } catch (Dali::DaliException e) {
81388       {
81389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81390       };
81391     } catch (...) {
81392       {
81393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81394       };
81395     }
81396   }
81397
81398 }
81399
81400
81401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
81402   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81403   unsigned int arg2 ;
81404
81405   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81406   arg2 = (unsigned int)jarg2;
81407   {
81408     try {
81409       (arg1)->ScrollTo(arg2);
81410     } catch (std::out_of_range& e) {
81411       {
81412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81413       };
81414     } catch (std::exception& e) {
81415       {
81416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81417       };
81418     } catch (Dali::DaliException e) {
81419       {
81420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81421       };
81422     } catch (...) {
81423       {
81424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81425       };
81426     }
81427   }
81428
81429 }
81430
81431
81432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
81433   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81434   unsigned int arg2 ;
81435   float arg3 ;
81436
81437   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81438   arg2 = (unsigned int)jarg2;
81439   arg3 = (float)jarg3;
81440   {
81441     try {
81442       (arg1)->ScrollTo(arg2,arg3);
81443     } catch (std::out_of_range& e) {
81444       {
81445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81446       };
81447     } catch (std::exception& e) {
81448       {
81449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81450       };
81451     } catch (Dali::DaliException e) {
81452       {
81453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81454       };
81455     } catch (...) {
81456       {
81457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81458       };
81459     }
81460   }
81461
81462 }
81463
81464
81465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
81466   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81467   unsigned int arg2 ;
81468   float arg3 ;
81469   Dali::Toolkit::DirectionBias arg4 ;
81470
81471   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81472   arg2 = (unsigned int)jarg2;
81473   arg3 = (float)jarg3;
81474   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81475   {
81476     try {
81477       (arg1)->ScrollTo(arg2,arg3,arg4);
81478     } catch (std::out_of_range& e) {
81479       {
81480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81481       };
81482     } catch (std::exception& e) {
81483       {
81484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81485       };
81486     } catch (Dali::DaliException e) {
81487       {
81488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81489       };
81490     } catch (...) {
81491       {
81492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81493       };
81494     }
81495   }
81496
81497 }
81498
81499
81500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
81501   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81502   Dali::Actor *arg2 = 0 ;
81503
81504   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81505   arg2 = (Dali::Actor *)jarg2;
81506   if (!arg2) {
81507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
81508     return ;
81509   }
81510   {
81511     try {
81512       (arg1)->ScrollTo(*arg2);
81513     } catch (std::out_of_range& e) {
81514       {
81515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81516       };
81517     } catch (std::exception& e) {
81518       {
81519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81520       };
81521     } catch (Dali::DaliException e) {
81522       {
81523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81524       };
81525     } catch (...) {
81526       {
81527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81528       };
81529     }
81530   }
81531
81532 }
81533
81534
81535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
81536   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81537   Dali::Actor *arg2 = 0 ;
81538   float arg3 ;
81539
81540   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81541   arg2 = (Dali::Actor *)jarg2;
81542   if (!arg2) {
81543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
81544     return ;
81545   }
81546   arg3 = (float)jarg3;
81547   {
81548     try {
81549       (arg1)->ScrollTo(*arg2,arg3);
81550     } catch (std::out_of_range& e) {
81551       {
81552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81553       };
81554     } catch (std::exception& e) {
81555       {
81556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81557       };
81558     } catch (Dali::DaliException e) {
81559       {
81560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81561       };
81562     } catch (...) {
81563       {
81564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81565       };
81566     }
81567   }
81568
81569 }
81570
81571
81572 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
81573   unsigned int jresult ;
81574   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81575   bool result;
81576
81577   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81578   {
81579     try {
81580       result = (bool)(arg1)->ScrollToSnapPoint();
81581     } catch (std::out_of_range& e) {
81582       {
81583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81584       };
81585     } catch (std::exception& e) {
81586       {
81587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81588       };
81589     } catch (Dali::DaliException e) {
81590       {
81591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81592       };
81593     } catch (...) {
81594       {
81595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81596       };
81597     }
81598   }
81599
81600   jresult = result;
81601   return jresult;
81602 }
81603
81604
81605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
81606   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81607   Dali::Constraint arg2 ;
81608   Dali::Constraint *argp2 ;
81609
81610   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81611   argp2 = (Dali::Constraint *)jarg2;
81612   if (!argp2) {
81613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
81614     return ;
81615   }
81616   arg2 = *argp2;
81617   {
81618     try {
81619       (arg1)->ApplyConstraintToChildren(arg2);
81620     } catch (std::out_of_range& e) {
81621       {
81622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81623       };
81624     } catch (std::exception& e) {
81625       {
81626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81627       };
81628     } catch (Dali::DaliException e) {
81629       {
81630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81631       };
81632     } catch (...) {
81633       {
81634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81635       };
81636     }
81637   }
81638
81639 }
81640
81641
81642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
81643   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81644
81645   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81646   {
81647     try {
81648       (arg1)->RemoveConstraintsFromChildren();
81649     } catch (std::out_of_range& e) {
81650       {
81651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81652       };
81653     } catch (std::exception& e) {
81654       {
81655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81656       };
81657     } catch (Dali::DaliException e) {
81658       {
81659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81660       };
81661     } catch (...) {
81662       {
81663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81664       };
81665     }
81666   }
81667
81668 }
81669
81670
81671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
81672   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81673   Dali::Toolkit::ScrollViewEffect arg2 ;
81674   Dali::Toolkit::ScrollViewEffect *argp2 ;
81675
81676   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81677   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
81678   if (!argp2) {
81679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
81680     return ;
81681   }
81682   arg2 = *argp2;
81683   {
81684     try {
81685       (arg1)->ApplyEffect(arg2);
81686     } catch (std::out_of_range& e) {
81687       {
81688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81689       };
81690     } catch (std::exception& e) {
81691       {
81692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81693       };
81694     } catch (Dali::DaliException e) {
81695       {
81696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81697       };
81698     } catch (...) {
81699       {
81700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81701       };
81702     }
81703   }
81704
81705 }
81706
81707
81708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
81709   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81710   Dali::Toolkit::ScrollViewEffect arg2 ;
81711   Dali::Toolkit::ScrollViewEffect *argp2 ;
81712
81713   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81714   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
81715   if (!argp2) {
81716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
81717     return ;
81718   }
81719   arg2 = *argp2;
81720   {
81721     try {
81722       (arg1)->RemoveEffect(arg2);
81723     } catch (std::out_of_range& e) {
81724       {
81725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81726       };
81727     } catch (std::exception& e) {
81728       {
81729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81730       };
81731     } catch (Dali::DaliException e) {
81732       {
81733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81734       };
81735     } catch (...) {
81736       {
81737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81738       };
81739     }
81740   }
81741
81742 }
81743
81744
81745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
81746   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81747
81748   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81749   {
81750     try {
81751       (arg1)->RemoveAllEffects();
81752     } catch (std::out_of_range& e) {
81753       {
81754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81755       };
81756     } catch (std::exception& e) {
81757       {
81758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81759       };
81760     } catch (Dali::DaliException e) {
81761       {
81762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81763       };
81764     } catch (...) {
81765       {
81766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81767       };
81768     }
81769   }
81770
81771 }
81772
81773
81774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
81775   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81776   Dali::Actor arg2 ;
81777   Dali::Actor *argp2 ;
81778
81779   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81780   argp2 = (Dali::Actor *)jarg2;
81781   if (!argp2) {
81782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81783     return ;
81784   }
81785   arg2 = *argp2;
81786   {
81787     try {
81788       (arg1)->BindActor(arg2);
81789     } catch (std::out_of_range& e) {
81790       {
81791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81792       };
81793     } catch (std::exception& e) {
81794       {
81795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81796       };
81797     } catch (Dali::DaliException e) {
81798       {
81799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81800       };
81801     } catch (...) {
81802       {
81803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81804       };
81805     }
81806   }
81807
81808 }
81809
81810
81811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
81812   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81813   Dali::Actor arg2 ;
81814   Dali::Actor *argp2 ;
81815
81816   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81817   argp2 = (Dali::Actor *)jarg2;
81818   if (!argp2) {
81819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81820     return ;
81821   }
81822   arg2 = *argp2;
81823   {
81824     try {
81825       (arg1)->UnbindActor(arg2);
81826     } catch (std::out_of_range& e) {
81827       {
81828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81829       };
81830     } catch (std::exception& e) {
81831       {
81832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81833       };
81834     } catch (Dali::DaliException e) {
81835       {
81836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81837       };
81838     } catch (...) {
81839       {
81840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81841       };
81842     }
81843   }
81844
81845 }
81846
81847
81848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
81849   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81850   Dali::Radian arg2 ;
81851   Dali::Radian arg3 ;
81852   Dali::Radian *argp2 ;
81853   Dali::Radian *argp3 ;
81854
81855   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81856   argp2 = (Dali::Radian *)jarg2;
81857   if (!argp2) {
81858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81859     return ;
81860   }
81861   arg2 = *argp2;
81862   argp3 = (Dali::Radian *)jarg3;
81863   if (!argp3) {
81864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81865     return ;
81866   }
81867   arg3 = *argp3;
81868   {
81869     try {
81870       (arg1)->SetScrollingDirection(arg2,arg3);
81871     } catch (std::out_of_range& e) {
81872       {
81873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81874       };
81875     } catch (std::exception& e) {
81876       {
81877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81878       };
81879     } catch (Dali::DaliException e) {
81880       {
81881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81882       };
81883     } catch (...) {
81884       {
81885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81886       };
81887     }
81888   }
81889
81890 }
81891
81892
81893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
81894   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81895   Dali::Radian arg2 ;
81896   Dali::Radian *argp2 ;
81897
81898   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81899   argp2 = (Dali::Radian *)jarg2;
81900   if (!argp2) {
81901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81902     return ;
81903   }
81904   arg2 = *argp2;
81905   {
81906     try {
81907       (arg1)->SetScrollingDirection(arg2);
81908     } catch (std::out_of_range& e) {
81909       {
81910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81911       };
81912     } catch (std::exception& e) {
81913       {
81914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81915       };
81916     } catch (Dali::DaliException e) {
81917       {
81918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81919       };
81920     } catch (...) {
81921       {
81922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81923       };
81924     }
81925   }
81926
81927 }
81928
81929
81930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
81931   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81932   Dali::Radian arg2 ;
81933   Dali::Radian *argp2 ;
81934
81935   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81936   argp2 = (Dali::Radian *)jarg2;
81937   if (!argp2) {
81938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81939     return ;
81940   }
81941   arg2 = *argp2;
81942   {
81943     try {
81944       (arg1)->RemoveScrollingDirection(arg2);
81945     } catch (std::out_of_range& e) {
81946       {
81947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81948       };
81949     } catch (std::exception& e) {
81950       {
81951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81952       };
81953     } catch (Dali::DaliException e) {
81954       {
81955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81956       };
81957     } catch (...) {
81958       {
81959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81960       };
81961     }
81962   }
81963
81964 }
81965
81966
81967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
81968   void * jresult ;
81969   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81970   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
81971
81972   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81973   {
81974     try {
81975       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
81976     } catch (std::out_of_range& e) {
81977       {
81978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81979       };
81980     } catch (std::exception& e) {
81981       {
81982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81983       };
81984     } catch (Dali::DaliException e) {
81985       {
81986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81987       };
81988     } catch (...) {
81989       {
81990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81991       };
81992     }
81993   }
81994
81995   jresult = (void *)result;
81996   return jresult;
81997 }
81998
81999
82000 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
82001   int jresult ;
82002   int result;
82003
82004   result = (int)Dali::Toolkit::TableView::Property::ROWS;
82005   jresult = (int)result;
82006   return jresult;
82007 }
82008
82009
82010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
82011   int jresult ;
82012   int result;
82013
82014   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
82015   jresult = (int)result;
82016   return jresult;
82017 }
82018
82019
82020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
82021   int jresult ;
82022   int result;
82023
82024   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
82025   jresult = (int)result;
82026   return jresult;
82027 }
82028
82029
82030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
82031   int jresult ;
82032   int result;
82033
82034   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
82035   jresult = (int)result;
82036   return jresult;
82037 }
82038
82039
82040 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
82041   int jresult ;
82042   int result;
82043
82044   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
82045   jresult = (int)result;
82046   return jresult;
82047 }
82048
82049
82050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
82051   void * jresult ;
82052   Dali::Toolkit::TableView::Property *result = 0 ;
82053
82054   {
82055     try {
82056       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
82057     } catch (std::out_of_range& e) {
82058       {
82059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82060       };
82061     } catch (std::exception& e) {
82062       {
82063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82064       };
82065     } catch (Dali::DaliException e) {
82066       {
82067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82068       };
82069     } catch (...) {
82070       {
82071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82072       };
82073     }
82074   }
82075
82076   jresult = (void *)result;
82077   return jresult;
82078 }
82079
82080
82081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
82082   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
82083
82084   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
82085   {
82086     try {
82087       delete arg1;
82088     } catch (std::out_of_range& e) {
82089       {
82090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82091       };
82092     } catch (std::exception& e) {
82093       {
82094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82095       };
82096     } catch (Dali::DaliException e) {
82097       {
82098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82099       };
82100     } catch (...) {
82101       {
82102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82103       };
82104     }
82105   }
82106
82107 }
82108
82109
82110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
82111   int jresult ;
82112   int result;
82113
82114   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
82115   jresult = (int)result;
82116   return jresult;
82117 }
82118
82119
82120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
82121   int jresult ;
82122   int result;
82123
82124   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
82125   jresult = (int)result;
82126   return jresult;
82127 }
82128
82129
82130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
82131   int jresult ;
82132   int result;
82133
82134   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
82135   jresult = (int)result;
82136   return jresult;
82137 }
82138
82139
82140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
82141   int jresult ;
82142   int result;
82143
82144   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
82145   jresult = (int)result;
82146   return jresult;
82147 }
82148
82149
82150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
82151   int jresult ;
82152   int result;
82153
82154   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
82155   jresult = (int)result;
82156   return jresult;
82157 }
82158
82159
82160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
82161   void * jresult ;
82162   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
82163
82164   {
82165     try {
82166       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
82167     } catch (std::out_of_range& e) {
82168       {
82169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82170       };
82171     } catch (std::exception& e) {
82172       {
82173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82174       };
82175     } catch (Dali::DaliException e) {
82176       {
82177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82178       };
82179     } catch (...) {
82180       {
82181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82182       };
82183     }
82184   }
82185
82186   jresult = (void *)result;
82187   return jresult;
82188 }
82189
82190
82191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
82192   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
82193
82194   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
82195   {
82196     try {
82197       delete arg1;
82198     } catch (std::out_of_range& e) {
82199       {
82200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82201       };
82202     } catch (std::exception& e) {
82203       {
82204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82205       };
82206     } catch (Dali::DaliException e) {
82207       {
82208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82209       };
82210     } catch (...) {
82211       {
82212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82213       };
82214     }
82215   }
82216
82217 }
82218
82219
82220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
82221   void * jresult ;
82222   unsigned int arg1 ;
82223   unsigned int arg2 ;
82224   unsigned int arg3 ;
82225   unsigned int arg4 ;
82226   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82227
82228   arg1 = (unsigned int)jarg1;
82229   arg2 = (unsigned int)jarg2;
82230   arg3 = (unsigned int)jarg3;
82231   arg4 = (unsigned int)jarg4;
82232   {
82233     try {
82234       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
82235     } catch (std::out_of_range& e) {
82236       {
82237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82238       };
82239     } catch (std::exception& e) {
82240       {
82241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82242       };
82243     } catch (Dali::DaliException e) {
82244       {
82245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82246       };
82247     } catch (...) {
82248       {
82249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82250       };
82251     }
82252   }
82253
82254   jresult = (void *)result;
82255   return jresult;
82256 }
82257
82258
82259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
82260   void * jresult ;
82261   unsigned int arg1 ;
82262   unsigned int arg2 ;
82263   unsigned int arg3 ;
82264   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82265
82266   arg1 = (unsigned int)jarg1;
82267   arg2 = (unsigned int)jarg2;
82268   arg3 = (unsigned int)jarg3;
82269   {
82270     try {
82271       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
82272     } catch (std::out_of_range& e) {
82273       {
82274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82275       };
82276     } catch (std::exception& e) {
82277       {
82278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82279       };
82280     } catch (Dali::DaliException e) {
82281       {
82282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82283       };
82284     } catch (...) {
82285       {
82286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82287       };
82288     }
82289   }
82290
82291   jresult = (void *)result;
82292   return jresult;
82293 }
82294
82295
82296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
82297   void * jresult ;
82298   unsigned int arg1 ;
82299   unsigned int arg2 ;
82300   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82301
82302   arg1 = (unsigned int)jarg1;
82303   arg2 = (unsigned int)jarg2;
82304   {
82305     try {
82306       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
82307     } catch (std::out_of_range& e) {
82308       {
82309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82310       };
82311     } catch (std::exception& e) {
82312       {
82313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82314       };
82315     } catch (Dali::DaliException e) {
82316       {
82317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82318       };
82319     } catch (...) {
82320       {
82321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82322       };
82323     }
82324   }
82325
82326   jresult = (void *)result;
82327   return jresult;
82328 }
82329
82330
82331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
82332   void * jresult ;
82333   unsigned int arg1 ;
82334   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82335
82336   arg1 = (unsigned int)jarg1;
82337   {
82338     try {
82339       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
82340     } catch (std::out_of_range& e) {
82341       {
82342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82343       };
82344     } catch (std::exception& e) {
82345       {
82346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82347       };
82348     } catch (Dali::DaliException e) {
82349       {
82350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82351       };
82352     } catch (...) {
82353       {
82354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82355       };
82356     }
82357   }
82358
82359   jresult = (void *)result;
82360   return jresult;
82361 }
82362
82363
82364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
82365   void * jresult ;
82366   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82367
82368   {
82369     try {
82370       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
82371     } catch (std::out_of_range& e) {
82372       {
82373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82374       };
82375     } catch (std::exception& e) {
82376       {
82377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82378       };
82379     } catch (Dali::DaliException e) {
82380       {
82381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82382       };
82383     } catch (...) {
82384       {
82385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82386       };
82387     }
82388   }
82389
82390   jresult = (void *)result;
82391   return jresult;
82392 }
82393
82394
82395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
82396   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82397   unsigned int arg2 ;
82398
82399   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82400   arg2 = (unsigned int)jarg2;
82401   if (arg1) (arg1)->rowIndex = arg2;
82402 }
82403
82404
82405 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
82406   unsigned int jresult ;
82407   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82408   unsigned int result;
82409
82410   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82411   result = (unsigned int) ((arg1)->rowIndex);
82412   jresult = result;
82413   return jresult;
82414 }
82415
82416
82417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
82418   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82419   unsigned int arg2 ;
82420
82421   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82422   arg2 = (unsigned int)jarg2;
82423   if (arg1) (arg1)->columnIndex = arg2;
82424 }
82425
82426
82427 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
82428   unsigned int jresult ;
82429   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82430   unsigned int result;
82431
82432   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82433   result = (unsigned int) ((arg1)->columnIndex);
82434   jresult = result;
82435   return jresult;
82436 }
82437
82438
82439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
82440   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82441   unsigned int arg2 ;
82442
82443   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82444   arg2 = (unsigned int)jarg2;
82445   if (arg1) (arg1)->rowSpan = arg2;
82446 }
82447
82448
82449 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
82450   unsigned int jresult ;
82451   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82452   unsigned int result;
82453
82454   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82455   result = (unsigned int) ((arg1)->rowSpan);
82456   jresult = result;
82457   return jresult;
82458 }
82459
82460
82461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
82462   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82463   unsigned int arg2 ;
82464
82465   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82466   arg2 = (unsigned int)jarg2;
82467   if (arg1) (arg1)->columnSpan = arg2;
82468 }
82469
82470
82471 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
82472   unsigned int jresult ;
82473   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82474   unsigned int result;
82475
82476   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82477   result = (unsigned int) ((arg1)->columnSpan);
82478   jresult = result;
82479   return jresult;
82480 }
82481
82482
82483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
82484   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82485
82486   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82487   {
82488     try {
82489       delete arg1;
82490     } catch (std::out_of_range& e) {
82491       {
82492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82493       };
82494     } catch (std::exception& e) {
82495       {
82496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82497       };
82498     } catch (Dali::DaliException e) {
82499       {
82500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82501       };
82502     } catch (...) {
82503       {
82504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82505       };
82506     }
82507   }
82508
82509 }
82510
82511
82512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
82513   void * jresult ;
82514   Dali::Toolkit::TableView *result = 0 ;
82515
82516   {
82517     try {
82518       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
82519     } catch (std::out_of_range& e) {
82520       {
82521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82522       };
82523     } catch (std::exception& e) {
82524       {
82525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82526       };
82527     } catch (Dali::DaliException e) {
82528       {
82529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82530       };
82531     } catch (...) {
82532       {
82533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82534       };
82535     }
82536   }
82537
82538   jresult = (void *)result;
82539   return jresult;
82540 }
82541
82542
82543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
82544   void * jresult ;
82545   Dali::Toolkit::TableView *arg1 = 0 ;
82546   Dali::Toolkit::TableView *result = 0 ;
82547
82548   arg1 = (Dali::Toolkit::TableView *)jarg1;
82549   if (!arg1) {
82550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
82551     return 0;
82552   }
82553   {
82554     try {
82555       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
82556     } catch (std::out_of_range& e) {
82557       {
82558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82559       };
82560     } catch (std::exception& e) {
82561       {
82562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82563       };
82564     } catch (Dali::DaliException e) {
82565       {
82566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82567       };
82568     } catch (...) {
82569       {
82570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82571       };
82572     }
82573   }
82574
82575   jresult = (void *)result;
82576   return jresult;
82577 }
82578
82579
82580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
82581   void * jresult ;
82582   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82583   Dali::Toolkit::TableView *arg2 = 0 ;
82584   Dali::Toolkit::TableView *result = 0 ;
82585
82586   arg1 = (Dali::Toolkit::TableView *)jarg1;
82587   arg2 = (Dali::Toolkit::TableView *)jarg2;
82588   if (!arg2) {
82589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
82590     return 0;
82591   }
82592   {
82593     try {
82594       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
82595     } catch (std::out_of_range& e) {
82596       {
82597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82598       };
82599     } catch (std::exception& e) {
82600       {
82601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82602       };
82603     } catch (Dali::DaliException e) {
82604       {
82605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82606       };
82607     } catch (...) {
82608       {
82609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82610       };
82611     }
82612   }
82613
82614   jresult = (void *)result;
82615   return jresult;
82616 }
82617
82618
82619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
82620   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82621
82622   arg1 = (Dali::Toolkit::TableView *)jarg1;
82623   {
82624     try {
82625       delete arg1;
82626     } catch (std::out_of_range& e) {
82627       {
82628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82629       };
82630     } catch (std::exception& e) {
82631       {
82632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82633       };
82634     } catch (Dali::DaliException e) {
82635       {
82636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82637       };
82638     } catch (...) {
82639       {
82640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82641       };
82642     }
82643   }
82644
82645 }
82646
82647
82648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
82649   void * jresult ;
82650   unsigned int arg1 ;
82651   unsigned int arg2 ;
82652   Dali::Toolkit::TableView result;
82653
82654   arg1 = (unsigned int)jarg1;
82655   arg2 = (unsigned int)jarg2;
82656   {
82657     try {
82658       result = Dali::Toolkit::TableView::New(arg1,arg2);
82659     } catch (std::out_of_range& e) {
82660       {
82661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82662       };
82663     } catch (std::exception& e) {
82664       {
82665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82666       };
82667     } catch (Dali::DaliException e) {
82668       {
82669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82670       };
82671     } catch (...) {
82672       {
82673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82674       };
82675     }
82676   }
82677
82678   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
82679   return jresult;
82680 }
82681
82682
82683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
82684   void * jresult ;
82685   Dali::BaseHandle arg1 ;
82686   Dali::BaseHandle *argp1 ;
82687   Dali::Toolkit::TableView result;
82688
82689   argp1 = (Dali::BaseHandle *)jarg1;
82690   if (!argp1) {
82691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82692     return 0;
82693   }
82694   arg1 = *argp1;
82695   {
82696     try {
82697       result = Dali::Toolkit::TableView::DownCast(arg1);
82698     } catch (std::out_of_range& e) {
82699       {
82700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82701       };
82702     } catch (std::exception& e) {
82703       {
82704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82705       };
82706     } catch (Dali::DaliException e) {
82707       {
82708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82709       };
82710     } catch (...) {
82711       {
82712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82713       };
82714     }
82715   }
82716
82717   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
82718   return jresult;
82719 }
82720
82721
82722 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
82723   unsigned int jresult ;
82724   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82725   Dali::Actor arg2 ;
82726   Dali::Toolkit::TableView::CellPosition arg3 ;
82727   Dali::Actor *argp2 ;
82728   Dali::Toolkit::TableView::CellPosition *argp3 ;
82729   bool result;
82730
82731   arg1 = (Dali::Toolkit::TableView *)jarg1;
82732   argp2 = (Dali::Actor *)jarg2;
82733   if (!argp2) {
82734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82735     return 0;
82736   }
82737   arg2 = *argp2;
82738   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
82739   if (!argp3) {
82740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82741     return 0;
82742   }
82743   arg3 = *argp3;
82744   {
82745     try {
82746       result = (bool)(arg1)->AddChild(arg2,arg3);
82747     } catch (std::out_of_range& e) {
82748       {
82749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82750       };
82751     } catch (std::exception& e) {
82752       {
82753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82754       };
82755     } catch (Dali::DaliException e) {
82756       {
82757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82758       };
82759     } catch (...) {
82760       {
82761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82762       };
82763     }
82764   }
82765
82766   jresult = result;
82767   return jresult;
82768 }
82769
82770
82771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
82772   void * jresult ;
82773   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82774   Dali::Toolkit::TableView::CellPosition arg2 ;
82775   Dali::Toolkit::TableView::CellPosition *argp2 ;
82776   Dali::Actor result;
82777
82778   arg1 = (Dali::Toolkit::TableView *)jarg1;
82779   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
82780   if (!argp2) {
82781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82782     return 0;
82783   }
82784   arg2 = *argp2;
82785   {
82786     try {
82787       result = (arg1)->GetChildAt(arg2);
82788     } catch (std::out_of_range& e) {
82789       {
82790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82791       };
82792     } catch (std::exception& e) {
82793       {
82794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82795       };
82796     } catch (Dali::DaliException e) {
82797       {
82798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82799       };
82800     } catch (...) {
82801       {
82802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82803       };
82804     }
82805   }
82806
82807   jresult = new Dali::Actor((const Dali::Actor &)result);
82808   return jresult;
82809 }
82810
82811
82812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
82813   void * jresult ;
82814   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82815   Dali::Toolkit::TableView::CellPosition arg2 ;
82816   Dali::Toolkit::TableView::CellPosition *argp2 ;
82817   Dali::Actor result;
82818
82819   arg1 = (Dali::Toolkit::TableView *)jarg1;
82820   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
82821   if (!argp2) {
82822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82823     return 0;
82824   }
82825   arg2 = *argp2;
82826   {
82827     try {
82828       result = (arg1)->RemoveChildAt(arg2);
82829     } catch (std::out_of_range& e) {
82830       {
82831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82832       };
82833     } catch (std::exception& e) {
82834       {
82835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82836       };
82837     } catch (Dali::DaliException e) {
82838       {
82839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82840       };
82841     } catch (...) {
82842       {
82843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82844       };
82845     }
82846   }
82847
82848   jresult = new Dali::Actor((const Dali::Actor &)result);
82849   return jresult;
82850 }
82851
82852
82853 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
82854   unsigned int jresult ;
82855   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82856   Dali::Actor arg2 ;
82857   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
82858   Dali::Actor *argp2 ;
82859   bool result;
82860
82861   arg1 = (Dali::Toolkit::TableView *)jarg1;
82862   argp2 = (Dali::Actor *)jarg2;
82863   if (!argp2) {
82864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82865     return 0;
82866   }
82867   arg2 = *argp2;
82868   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
82869   if (!arg3) {
82870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
82871     return 0;
82872   }
82873   {
82874     try {
82875       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
82876     } catch (std::out_of_range& e) {
82877       {
82878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82879       };
82880     } catch (std::exception& e) {
82881       {
82882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82883       };
82884     } catch (Dali::DaliException e) {
82885       {
82886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82887       };
82888     } catch (...) {
82889       {
82890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82891       };
82892     }
82893   }
82894
82895   jresult = result;
82896   return jresult;
82897 }
82898
82899
82900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
82901   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82902   unsigned int arg2 ;
82903
82904   arg1 = (Dali::Toolkit::TableView *)jarg1;
82905   arg2 = (unsigned int)jarg2;
82906   {
82907     try {
82908       (arg1)->InsertRow(arg2);
82909     } catch (std::out_of_range& e) {
82910       {
82911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82912       };
82913     } catch (std::exception& e) {
82914       {
82915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82916       };
82917     } catch (Dali::DaliException e) {
82918       {
82919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82920       };
82921     } catch (...) {
82922       {
82923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82924       };
82925     }
82926   }
82927
82928 }
82929
82930
82931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
82932   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82933   unsigned int arg2 ;
82934
82935   arg1 = (Dali::Toolkit::TableView *)jarg1;
82936   arg2 = (unsigned int)jarg2;
82937   {
82938     try {
82939       (arg1)->DeleteRow(arg2);
82940     } catch (std::out_of_range& e) {
82941       {
82942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82943       };
82944     } catch (std::exception& e) {
82945       {
82946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82947       };
82948     } catch (Dali::DaliException e) {
82949       {
82950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82951       };
82952     } catch (...) {
82953       {
82954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82955       };
82956     }
82957   }
82958
82959 }
82960
82961
82962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
82963   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82964   unsigned int arg2 ;
82965   std::vector< Dali::Actor > *arg3 = 0 ;
82966
82967   arg1 = (Dali::Toolkit::TableView *)jarg1;
82968   arg2 = (unsigned int)jarg2;
82969   arg3 = (std::vector< Dali::Actor > *)jarg3;
82970   if (!arg3) {
82971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
82972     return ;
82973   }
82974   {
82975     try {
82976       (arg1)->DeleteRow(arg2,*arg3);
82977     } catch (std::out_of_range& e) {
82978       {
82979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82980       };
82981     } catch (std::exception& e) {
82982       {
82983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82984       };
82985     } catch (Dali::DaliException e) {
82986       {
82987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82988       };
82989     } catch (...) {
82990       {
82991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82992       };
82993     }
82994   }
82995
82996 }
82997
82998
82999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
83000   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83001   unsigned int arg2 ;
83002
83003   arg1 = (Dali::Toolkit::TableView *)jarg1;
83004   arg2 = (unsigned int)jarg2;
83005   {
83006     try {
83007       (arg1)->InsertColumn(arg2);
83008     } catch (std::out_of_range& e) {
83009       {
83010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83011       };
83012     } catch (std::exception& e) {
83013       {
83014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83015       };
83016     } catch (Dali::DaliException e) {
83017       {
83018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83019       };
83020     } catch (...) {
83021       {
83022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83023       };
83024     }
83025   }
83026
83027 }
83028
83029
83030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
83031   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83032   unsigned int arg2 ;
83033
83034   arg1 = (Dali::Toolkit::TableView *)jarg1;
83035   arg2 = (unsigned int)jarg2;
83036   {
83037     try {
83038       (arg1)->DeleteColumn(arg2);
83039     } catch (std::out_of_range& e) {
83040       {
83041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83042       };
83043     } catch (std::exception& e) {
83044       {
83045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83046       };
83047     } catch (Dali::DaliException e) {
83048       {
83049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83050       };
83051     } catch (...) {
83052       {
83053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83054       };
83055     }
83056   }
83057
83058 }
83059
83060
83061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
83062   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83063   unsigned int arg2 ;
83064   std::vector< Dali::Actor > *arg3 = 0 ;
83065
83066   arg1 = (Dali::Toolkit::TableView *)jarg1;
83067   arg2 = (unsigned int)jarg2;
83068   arg3 = (std::vector< Dali::Actor > *)jarg3;
83069   if (!arg3) {
83070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83071     return ;
83072   }
83073   {
83074     try {
83075       (arg1)->DeleteColumn(arg2,*arg3);
83076     } catch (std::out_of_range& e) {
83077       {
83078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83079       };
83080     } catch (std::exception& e) {
83081       {
83082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83083       };
83084     } catch (Dali::DaliException e) {
83085       {
83086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83087       };
83088     } catch (...) {
83089       {
83090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83091       };
83092     }
83093   }
83094
83095 }
83096
83097
83098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
83099   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83100   unsigned int arg2 ;
83101   unsigned int arg3 ;
83102
83103   arg1 = (Dali::Toolkit::TableView *)jarg1;
83104   arg2 = (unsigned int)jarg2;
83105   arg3 = (unsigned int)jarg3;
83106   {
83107     try {
83108       (arg1)->Resize(arg2,arg3);
83109     } catch (std::out_of_range& e) {
83110       {
83111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83112       };
83113     } catch (std::exception& e) {
83114       {
83115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83116       };
83117     } catch (Dali::DaliException e) {
83118       {
83119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83120       };
83121     } catch (...) {
83122       {
83123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83124       };
83125     }
83126   }
83127
83128 }
83129
83130
83131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
83132   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83133   unsigned int arg2 ;
83134   unsigned int arg3 ;
83135   std::vector< Dali::Actor > *arg4 = 0 ;
83136
83137   arg1 = (Dali::Toolkit::TableView *)jarg1;
83138   arg2 = (unsigned int)jarg2;
83139   arg3 = (unsigned int)jarg3;
83140   arg4 = (std::vector< Dali::Actor > *)jarg4;
83141   if (!arg4) {
83142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83143     return ;
83144   }
83145   {
83146     try {
83147       (arg1)->Resize(arg2,arg3,*arg4);
83148     } catch (std::out_of_range& e) {
83149       {
83150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83151       };
83152     } catch (std::exception& e) {
83153       {
83154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83155       };
83156     } catch (Dali::DaliException e) {
83157       {
83158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83159       };
83160     } catch (...) {
83161       {
83162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83163       };
83164     }
83165   }
83166
83167 }
83168
83169
83170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
83171   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83172   Dali::Size arg2 ;
83173   Dali::Size *argp2 ;
83174
83175   arg1 = (Dali::Toolkit::TableView *)jarg1;
83176   argp2 = (Dali::Size *)jarg2;
83177   if (!argp2) {
83178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
83179     return ;
83180   }
83181   arg2 = *argp2;
83182   {
83183     try {
83184       (arg1)->SetCellPadding(arg2);
83185     } catch (std::out_of_range& e) {
83186       {
83187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83188       };
83189     } catch (std::exception& e) {
83190       {
83191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83192       };
83193     } catch (Dali::DaliException e) {
83194       {
83195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83196       };
83197     } catch (...) {
83198       {
83199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83200       };
83201     }
83202   }
83203
83204 }
83205
83206
83207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
83208   void * jresult ;
83209   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83210   Dali::Size result;
83211
83212   arg1 = (Dali::Toolkit::TableView *)jarg1;
83213   {
83214     try {
83215       result = (arg1)->GetCellPadding();
83216     } catch (std::out_of_range& e) {
83217       {
83218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83219       };
83220     } catch (std::exception& e) {
83221       {
83222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83223       };
83224     } catch (Dali::DaliException e) {
83225       {
83226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83227       };
83228     } catch (...) {
83229       {
83230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83231       };
83232     }
83233   }
83234
83235   jresult = new Dali::Size((const Dali::Size &)result);
83236   return jresult;
83237 }
83238
83239
83240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
83241   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83242   unsigned int arg2 ;
83243
83244   arg1 = (Dali::Toolkit::TableView *)jarg1;
83245   arg2 = (unsigned int)jarg2;
83246   {
83247     try {
83248       (arg1)->SetFitHeight(arg2);
83249     } catch (std::out_of_range& e) {
83250       {
83251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83252       };
83253     } catch (std::exception& e) {
83254       {
83255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83256       };
83257     } catch (Dali::DaliException e) {
83258       {
83259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83260       };
83261     } catch (...) {
83262       {
83263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83264       };
83265     }
83266   }
83267
83268 }
83269
83270
83271 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
83272   unsigned int jresult ;
83273   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83274   unsigned int arg2 ;
83275   bool result;
83276
83277   arg1 = (Dali::Toolkit::TableView *)jarg1;
83278   arg2 = (unsigned int)jarg2;
83279   {
83280     try {
83281       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
83282     } catch (std::out_of_range& e) {
83283       {
83284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83285       };
83286     } catch (std::exception& e) {
83287       {
83288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83289       };
83290     } catch (Dali::DaliException e) {
83291       {
83292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83293       };
83294     } catch (...) {
83295       {
83296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83297       };
83298     }
83299   }
83300
83301   jresult = result;
83302   return jresult;
83303 }
83304
83305
83306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
83307   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83308   unsigned int arg2 ;
83309
83310   arg1 = (Dali::Toolkit::TableView *)jarg1;
83311   arg2 = (unsigned int)jarg2;
83312   {
83313     try {
83314       (arg1)->SetFitWidth(arg2);
83315     } catch (std::out_of_range& e) {
83316       {
83317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83318       };
83319     } catch (std::exception& e) {
83320       {
83321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83322       };
83323     } catch (Dali::DaliException e) {
83324       {
83325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83326       };
83327     } catch (...) {
83328       {
83329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83330       };
83331     }
83332   }
83333
83334 }
83335
83336
83337 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
83338   unsigned int jresult ;
83339   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83340   unsigned int arg2 ;
83341   bool result;
83342
83343   arg1 = (Dali::Toolkit::TableView *)jarg1;
83344   arg2 = (unsigned int)jarg2;
83345   {
83346     try {
83347       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
83348     } catch (std::out_of_range& e) {
83349       {
83350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83351       };
83352     } catch (std::exception& e) {
83353       {
83354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83355       };
83356     } catch (Dali::DaliException e) {
83357       {
83358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83359       };
83360     } catch (...) {
83361       {
83362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83363       };
83364     }
83365   }
83366
83367   jresult = result;
83368   return jresult;
83369 }
83370
83371
83372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83373   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83374   unsigned int arg2 ;
83375   float arg3 ;
83376
83377   arg1 = (Dali::Toolkit::TableView *)jarg1;
83378   arg2 = (unsigned int)jarg2;
83379   arg3 = (float)jarg3;
83380   {
83381     try {
83382       (arg1)->SetFixedHeight(arg2,arg3);
83383     } catch (std::out_of_range& e) {
83384       {
83385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83386       };
83387     } catch (std::exception& e) {
83388       {
83389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83390       };
83391     } catch (Dali::DaliException e) {
83392       {
83393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83394       };
83395     } catch (...) {
83396       {
83397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83398       };
83399     }
83400   }
83401
83402 }
83403
83404
83405 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
83406   float jresult ;
83407   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83408   unsigned int arg2 ;
83409   float result;
83410
83411   arg1 = (Dali::Toolkit::TableView *)jarg1;
83412   arg2 = (unsigned int)jarg2;
83413   {
83414     try {
83415       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
83416     } catch (std::out_of_range& e) {
83417       {
83418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83419       };
83420     } catch (std::exception& e) {
83421       {
83422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83423       };
83424     } catch (Dali::DaliException e) {
83425       {
83426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83427       };
83428     } catch (...) {
83429       {
83430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83431       };
83432     }
83433   }
83434
83435   jresult = result;
83436   return jresult;
83437 }
83438
83439
83440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83441   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83442   unsigned int arg2 ;
83443   float arg3 ;
83444
83445   arg1 = (Dali::Toolkit::TableView *)jarg1;
83446   arg2 = (unsigned int)jarg2;
83447   arg3 = (float)jarg3;
83448   {
83449     try {
83450       (arg1)->SetRelativeHeight(arg2,arg3);
83451     } catch (std::out_of_range& e) {
83452       {
83453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83454       };
83455     } catch (std::exception& e) {
83456       {
83457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83458       };
83459     } catch (Dali::DaliException e) {
83460       {
83461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83462       };
83463     } catch (...) {
83464       {
83465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83466       };
83467     }
83468   }
83469
83470 }
83471
83472
83473 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
83474   float jresult ;
83475   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83476   unsigned int arg2 ;
83477   float result;
83478
83479   arg1 = (Dali::Toolkit::TableView *)jarg1;
83480   arg2 = (unsigned int)jarg2;
83481   {
83482     try {
83483       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
83484     } catch (std::out_of_range& e) {
83485       {
83486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83487       };
83488     } catch (std::exception& e) {
83489       {
83490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83491       };
83492     } catch (Dali::DaliException e) {
83493       {
83494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83495       };
83496     } catch (...) {
83497       {
83498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83499       };
83500     }
83501   }
83502
83503   jresult = result;
83504   return jresult;
83505 }
83506
83507
83508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
83509   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83510   unsigned int arg2 ;
83511   float arg3 ;
83512
83513   arg1 = (Dali::Toolkit::TableView *)jarg1;
83514   arg2 = (unsigned int)jarg2;
83515   arg3 = (float)jarg3;
83516   {
83517     try {
83518       (arg1)->SetFixedWidth(arg2,arg3);
83519     } catch (std::out_of_range& e) {
83520       {
83521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83522       };
83523     } catch (std::exception& e) {
83524       {
83525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83526       };
83527     } catch (Dali::DaliException e) {
83528       {
83529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83530       };
83531     } catch (...) {
83532       {
83533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83534       };
83535     }
83536   }
83537
83538 }
83539
83540
83541 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
83542   float jresult ;
83543   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83544   unsigned int arg2 ;
83545   float result;
83546
83547   arg1 = (Dali::Toolkit::TableView *)jarg1;
83548   arg2 = (unsigned int)jarg2;
83549   {
83550     try {
83551       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
83552     } catch (std::out_of_range& e) {
83553       {
83554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83555       };
83556     } catch (std::exception& e) {
83557       {
83558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83559       };
83560     } catch (Dali::DaliException e) {
83561       {
83562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83563       };
83564     } catch (...) {
83565       {
83566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83567       };
83568     }
83569   }
83570
83571   jresult = result;
83572   return jresult;
83573 }
83574
83575
83576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
83577   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83578   unsigned int arg2 ;
83579   float arg3 ;
83580
83581   arg1 = (Dali::Toolkit::TableView *)jarg1;
83582   arg2 = (unsigned int)jarg2;
83583   arg3 = (float)jarg3;
83584   {
83585     try {
83586       (arg1)->SetRelativeWidth(arg2,arg3);
83587     } catch (std::out_of_range& e) {
83588       {
83589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83590       };
83591     } catch (std::exception& e) {
83592       {
83593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83594       };
83595     } catch (Dali::DaliException e) {
83596       {
83597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83598       };
83599     } catch (...) {
83600       {
83601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83602       };
83603     }
83604   }
83605
83606 }
83607
83608
83609 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
83610   float jresult ;
83611   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83612   unsigned int arg2 ;
83613   float result;
83614
83615   arg1 = (Dali::Toolkit::TableView *)jarg1;
83616   arg2 = (unsigned int)jarg2;
83617   {
83618     try {
83619       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
83620     } catch (std::out_of_range& e) {
83621       {
83622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83623       };
83624     } catch (std::exception& e) {
83625       {
83626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83627       };
83628     } catch (Dali::DaliException e) {
83629       {
83630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83631       };
83632     } catch (...) {
83633       {
83634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83635       };
83636     }
83637   }
83638
83639   jresult = result;
83640   return jresult;
83641 }
83642
83643
83644 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
83645   unsigned int jresult ;
83646   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83647   unsigned int result;
83648
83649   arg1 = (Dali::Toolkit::TableView *)jarg1;
83650   {
83651     try {
83652       result = (unsigned int)(arg1)->GetRows();
83653     } catch (std::out_of_range& e) {
83654       {
83655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83656       };
83657     } catch (std::exception& e) {
83658       {
83659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83660       };
83661     } catch (Dali::DaliException e) {
83662       {
83663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83664       };
83665     } catch (...) {
83666       {
83667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83668       };
83669     }
83670   }
83671
83672   jresult = result;
83673   return jresult;
83674 }
83675
83676
83677 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
83678   unsigned int jresult ;
83679   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83680   unsigned int result;
83681
83682   arg1 = (Dali::Toolkit::TableView *)jarg1;
83683   {
83684     try {
83685       result = (unsigned int)(arg1)->GetColumns();
83686     } catch (std::out_of_range& e) {
83687       {
83688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83689       };
83690     } catch (std::exception& e) {
83691       {
83692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83693       };
83694     } catch (Dali::DaliException e) {
83695       {
83696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83697       };
83698     } catch (...) {
83699       {
83700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83701       };
83702     }
83703   }
83704
83705   jresult = result;
83706   return jresult;
83707 }
83708
83709
83710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
83711   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83712   Dali::Toolkit::TableView::CellPosition arg2 ;
83713   Dali::HorizontalAlignment::Type arg3 ;
83714   Dali::VerticalAlignment::Type arg4 ;
83715   Dali::Toolkit::TableView::CellPosition *argp2 ;
83716
83717   arg1 = (Dali::Toolkit::TableView *)jarg1;
83718   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
83719   if (!argp2) {
83720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83721     return ;
83722   }
83723   arg2 = *argp2;
83724   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
83725   arg4 = (Dali::VerticalAlignment::Type)jarg4;
83726   {
83727     try {
83728       (arg1)->SetCellAlignment(arg2,arg3,arg4);
83729     } catch (std::out_of_range& e) {
83730       {
83731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83732       };
83733     } catch (std::exception& e) {
83734       {
83735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83736       };
83737     } catch (Dali::DaliException e) {
83738       {
83739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83740       };
83741     } catch (...) {
83742       {
83743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83744       };
83745     }
83746   }
83747
83748 }
83749
83750
83751 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
83752   unsigned int jresult ;
83753   unsigned int result;
83754
83755   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
83756   jresult = result;
83757   return jresult;
83758 }
83759
83760
83761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
83762   int jresult ;
83763   int result;
83764
83765   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
83766   jresult = (int)result;
83767   return jresult;
83768 }
83769
83770
83771 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
83772   int jresult ;
83773   int result;
83774
83775   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
83776   jresult = (int)result;
83777   return jresult;
83778 }
83779
83780
83781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
83782   int jresult ;
83783   int result;
83784
83785   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
83786   jresult = (int)result;
83787   return jresult;
83788 }
83789
83790
83791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
83792   int jresult ;
83793   int result;
83794
83795   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
83796   jresult = (int)result;
83797   return jresult;
83798 }
83799
83800
83801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
83802   int jresult ;
83803   int result;
83804
83805   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
83806   jresult = (int)result;
83807   return jresult;
83808 }
83809
83810
83811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
83812   int jresult ;
83813   int result;
83814
83815   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
83816   jresult = (int)result;
83817   return jresult;
83818 }
83819
83820
83821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
83822   int jresult ;
83823   int result;
83824
83825   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
83826   jresult = (int)result;
83827   return jresult;
83828 }
83829
83830
83831 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
83832   int jresult ;
83833   int result;
83834
83835   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
83836   jresult = (int)result;
83837   return jresult;
83838 }
83839
83840
83841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
83842   int jresult ;
83843   int result;
83844
83845   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
83846   jresult = (int)result;
83847   return jresult;
83848 }
83849
83850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
83851   int jresult ;
83852   int result;
83853
83854   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
83855   jresult = (int)result;
83856   return jresult;
83857 }
83858
83859
83860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
83861   int jresult ;
83862   int result;
83863
83864   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
83865   jresult = (int)result;
83866   return jresult;
83867 }
83868
83869
83870 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
83871   int jresult ;
83872   int result;
83873
83874   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
83875   jresult = (int)result;
83876   return jresult;
83877 }
83878
83879
83880 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
83881   int jresult ;
83882   int result;
83883
83884   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
83885   jresult = (int)result;
83886   return jresult;
83887 }
83888
83889
83890 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
83891   int jresult ;
83892   int result;
83893
83894   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
83895   jresult = (int)result;
83896   return jresult;
83897 }
83898
83899
83900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
83901   int jresult ;
83902   int result;
83903
83904   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
83905   jresult = (int)result;
83906   return jresult;
83907 }
83908
83909
83910 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
83911   int jresult ;
83912   int result;
83913
83914   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
83915   jresult = (int)result;
83916   return jresult;
83917 }
83918
83919
83920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
83921   int jresult ;
83922   int result;
83923
83924   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
83925   jresult = (int)result;
83926   return jresult;
83927 }
83928
83929
83930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
83931   int jresult ;
83932   int result;
83933
83934   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
83935   jresult = (int)result;
83936   return jresult;
83937 }
83938
83939
83940 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
83941   int jresult ;
83942   int result;
83943
83944   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
83945   jresult = (int)result;
83946   return jresult;
83947 }
83948
83949
83950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
83951   int jresult ;
83952   int result;
83953
83954   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
83955   jresult = (int)result;
83956   return jresult;
83957 }
83958
83959
83960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
83961   int jresult ;
83962   int result;
83963
83964   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
83965   jresult = (int)result;
83966   return jresult;
83967 }
83968
83969
83970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
83971   int jresult ;
83972   int result;
83973
83974   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
83975   jresult = (int)result;
83976   return jresult;
83977 }
83978
83979
83980 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
83981   int jresult ;
83982   int result;
83983
83984   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
83985   jresult = (int)result;
83986   return jresult;
83987 }
83988
83989
83990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
83991   int jresult ;
83992   int result;
83993
83994   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
83995   jresult = (int)result;
83996   return jresult;
83997 }
83998
83999
84000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
84001   void * jresult ;
84002   Dali::Toolkit::TextLabel::Property *result = 0 ;
84003
84004   {
84005     try {
84006       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
84007     } catch (std::out_of_range& e) {
84008       {
84009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84010       };
84011     } catch (std::exception& e) {
84012       {
84013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84014       };
84015     } catch (Dali::DaliException e) {
84016       {
84017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84018       };
84019     } catch (...) {
84020       {
84021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84022       };
84023     }
84024   }
84025
84026   jresult = (void *)result;
84027   return jresult;
84028 }
84029
84030
84031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
84032   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
84033
84034   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
84035   {
84036     try {
84037       delete arg1;
84038     } catch (std::out_of_range& e) {
84039       {
84040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84041       };
84042     } catch (std::exception& e) {
84043       {
84044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84045       };
84046     } catch (Dali::DaliException e) {
84047       {
84048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84049       };
84050     } catch (...) {
84051       {
84052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84053       };
84054     }
84055   }
84056
84057 }
84058
84059
84060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
84061   void * jresult ;
84062   Dali::Toolkit::TextLabel result;
84063
84064   {
84065     try {
84066       result = Dali::Toolkit::TextLabel::New();
84067     } catch (std::out_of_range& e) {
84068       {
84069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84070       };
84071     } catch (std::exception& e) {
84072       {
84073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84074       };
84075     } catch (Dali::DaliException e) {
84076       {
84077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84078       };
84079     } catch (...) {
84080       {
84081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84082       };
84083     }
84084   }
84085
84086   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84087   return jresult;
84088 }
84089
84090
84091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
84092   void * jresult ;
84093   std::string *arg1 = 0 ;
84094   Dali::Toolkit::TextLabel result;
84095
84096   if (!jarg1) {
84097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84098     return 0;
84099   }
84100   std::string arg1_str(jarg1);
84101   arg1 = &arg1_str;
84102   {
84103     try {
84104       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
84105     } catch (std::out_of_range& e) {
84106       {
84107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84108       };
84109     } catch (std::exception& e) {
84110       {
84111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84112       };
84113     } catch (Dali::DaliException e) {
84114       {
84115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84116       };
84117     } catch (...) {
84118       {
84119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84120       };
84121     }
84122   }
84123
84124   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84125
84126   //argout typemap for const std::string&
84127
84128   return jresult;
84129 }
84130
84131
84132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
84133   void * jresult ;
84134   Dali::Toolkit::TextLabel *result = 0 ;
84135
84136   {
84137     try {
84138       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
84139     } catch (std::out_of_range& e) {
84140       {
84141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84142       };
84143     } catch (std::exception& e) {
84144       {
84145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84146       };
84147     } catch (Dali::DaliException e) {
84148       {
84149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84150       };
84151     } catch (...) {
84152       {
84153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84154       };
84155     }
84156   }
84157
84158   jresult = (void *)result;
84159   return jresult;
84160 }
84161
84162
84163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
84164   void * jresult ;
84165   Dali::Toolkit::TextLabel *arg1 = 0 ;
84166   Dali::Toolkit::TextLabel *result = 0 ;
84167
84168   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84169   if (!arg1) {
84170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84171     return 0;
84172   }
84173   {
84174     try {
84175       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
84176     } catch (std::out_of_range& e) {
84177       {
84178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84179       };
84180     } catch (std::exception& e) {
84181       {
84182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84183       };
84184     } catch (Dali::DaliException e) {
84185       {
84186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84187       };
84188     } catch (...) {
84189       {
84190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84191       };
84192     }
84193   }
84194
84195   jresult = (void *)result;
84196   return jresult;
84197 }
84198
84199
84200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
84201   void * jresult ;
84202   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84203   Dali::Toolkit::TextLabel *arg2 = 0 ;
84204   Dali::Toolkit::TextLabel *result = 0 ;
84205
84206   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84207   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
84208   if (!arg2) {
84209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84210     return 0;
84211   }
84212   {
84213     try {
84214       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
84215     } catch (std::out_of_range& e) {
84216       {
84217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84218       };
84219     } catch (std::exception& e) {
84220       {
84221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84222       };
84223     } catch (Dali::DaliException e) {
84224       {
84225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84226       };
84227     } catch (...) {
84228       {
84229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84230       };
84231     }
84232   }
84233
84234   jresult = (void *)result;
84235   return jresult;
84236 }
84237
84238
84239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
84240   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84241
84242   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84243   {
84244     try {
84245       delete arg1;
84246     } catch (std::out_of_range& e) {
84247       {
84248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84249       };
84250     } catch (std::exception& e) {
84251       {
84252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84253       };
84254     } catch (Dali::DaliException e) {
84255       {
84256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84257       };
84258     } catch (...) {
84259       {
84260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84261       };
84262     }
84263   }
84264
84265 }
84266
84267
84268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
84269   void * jresult ;
84270   Dali::BaseHandle arg1 ;
84271   Dali::BaseHandle *argp1 ;
84272   Dali::Toolkit::TextLabel result;
84273
84274   argp1 = (Dali::BaseHandle *)jarg1;
84275   if (!argp1) {
84276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84277     return 0;
84278   }
84279   arg1 = *argp1;
84280   {
84281     try {
84282       result = Dali::Toolkit::TextLabel::DownCast(arg1);
84283     } catch (std::out_of_range& e) {
84284       {
84285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84286       };
84287     } catch (std::exception& e) {
84288       {
84289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84290       };
84291     } catch (Dali::DaliException e) {
84292       {
84293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84294       };
84295     } catch (...) {
84296       {
84297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84298       };
84299     }
84300   }
84301
84302   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84303   return jresult;
84304 }
84305
84306
84307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
84308   void * jresult ;
84309   Dali::Toolkit::AccessibilityManager *result = 0 ;
84310
84311   {
84312     try {
84313       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
84314     } catch (std::out_of_range& e) {
84315       {
84316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84317       };
84318     } catch (std::exception& e) {
84319       {
84320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84321       };
84322     } catch (Dali::DaliException e) {
84323       {
84324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84325       };
84326     } catch (...) {
84327       {
84328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84329       };
84330     }
84331   }
84332
84333   jresult = (void *)result;
84334   return jresult;
84335 }
84336
84337
84338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
84339   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84340
84341   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84342   {
84343     try {
84344       delete arg1;
84345     } catch (std::out_of_range& e) {
84346       {
84347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84348       };
84349     } catch (std::exception& e) {
84350       {
84351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84352       };
84353     } catch (Dali::DaliException e) {
84354       {
84355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84356       };
84357     } catch (...) {
84358       {
84359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84360       };
84361     }
84362   }
84363
84364 }
84365
84366
84367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
84368   void * jresult ;
84369   Dali::Toolkit::AccessibilityManager result;
84370
84371   {
84372     try {
84373       result = Dali::Toolkit::AccessibilityManager::Get();
84374     } catch (std::out_of_range& e) {
84375       {
84376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84377       };
84378     } catch (std::exception& e) {
84379       {
84380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84381       };
84382     } catch (Dali::DaliException e) {
84383       {
84384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84385       };
84386     } catch (...) {
84387       {
84388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84389       };
84390     }
84391   }
84392
84393   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
84394   return jresult;
84395 }
84396
84397
84398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
84399   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84400   Dali::Actor arg2 ;
84401   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84402   std::string *arg4 = 0 ;
84403   Dali::Actor *argp2 ;
84404
84405   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84406   argp2 = (Dali::Actor *)jarg2;
84407   if (!argp2) {
84408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84409     return ;
84410   }
84411   arg2 = *argp2;
84412   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84413   if (!jarg4) {
84414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84415     return ;
84416   }
84417   std::string arg4_str(jarg4);
84418   arg4 = &arg4_str;
84419   {
84420     try {
84421       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
84422     } catch (std::out_of_range& e) {
84423       {
84424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84425       };
84426     } catch (std::exception& e) {
84427       {
84428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84429       };
84430     } catch (Dali::DaliException e) {
84431       {
84432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84433       };
84434     } catch (...) {
84435       {
84436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84437       };
84438     }
84439   }
84440
84441
84442   //argout typemap for const std::string&
84443
84444 }
84445
84446
84447 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
84448   char * jresult ;
84449   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84450   Dali::Actor arg2 ;
84451   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84452   Dali::Actor *argp2 ;
84453   std::string result;
84454
84455   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84456   argp2 = (Dali::Actor *)jarg2;
84457   if (!argp2) {
84458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84459     return 0;
84460   }
84461   arg2 = *argp2;
84462   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84463   {
84464     try {
84465       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
84466     } catch (std::out_of_range& e) {
84467       {
84468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84469       };
84470     } catch (std::exception& e) {
84471       {
84472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84473       };
84474     } catch (Dali::DaliException e) {
84475       {
84476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84477       };
84478     } catch (...) {
84479       {
84480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84481       };
84482     }
84483   }
84484
84485   jresult = SWIG_csharp_string_callback((&result)->c_str());
84486   return jresult;
84487 }
84488
84489
84490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
84491   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84492   Dali::Actor arg2 ;
84493   unsigned int arg3 ;
84494   Dali::Actor *argp2 ;
84495
84496   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84497   argp2 = (Dali::Actor *)jarg2;
84498   if (!argp2) {
84499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84500     return ;
84501   }
84502   arg2 = *argp2;
84503   arg3 = (unsigned int)jarg3;
84504   {
84505     try {
84506       (arg1)->SetFocusOrder(arg2,arg3);
84507     } catch (std::out_of_range& e) {
84508       {
84509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84510       };
84511     } catch (std::exception& e) {
84512       {
84513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84514       };
84515     } catch (Dali::DaliException e) {
84516       {
84517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84518       };
84519     } catch (...) {
84520       {
84521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84522       };
84523     }
84524   }
84525
84526 }
84527
84528
84529 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
84530   unsigned int jresult ;
84531   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84532   Dali::Actor arg2 ;
84533   Dali::Actor *argp2 ;
84534   unsigned int result;
84535
84536   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84537   argp2 = (Dali::Actor *)jarg2;
84538   if (!argp2) {
84539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84540     return 0;
84541   }
84542   arg2 = *argp2;
84543   {
84544     try {
84545       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
84546     } catch (std::out_of_range& e) {
84547       {
84548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84549       };
84550     } catch (std::exception& e) {
84551       {
84552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84553       };
84554     } catch (Dali::DaliException e) {
84555       {
84556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84557       };
84558     } catch (...) {
84559       {
84560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84561       };
84562     }
84563   }
84564
84565   jresult = result;
84566   return jresult;
84567 }
84568
84569
84570 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
84571   unsigned int jresult ;
84572   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84573   unsigned int result;
84574
84575   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84576   {
84577     try {
84578       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
84579     } catch (std::out_of_range& e) {
84580       {
84581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84582       };
84583     } catch (std::exception& e) {
84584       {
84585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84586       };
84587     } catch (Dali::DaliException e) {
84588       {
84589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84590       };
84591     } catch (...) {
84592       {
84593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84594       };
84595     }
84596   }
84597
84598   jresult = result;
84599   return jresult;
84600 }
84601
84602
84603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
84604   void * jresult ;
84605   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84606   unsigned int arg2 ;
84607   Dali::Actor result;
84608
84609   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84610   arg2 = (unsigned int)jarg2;
84611   {
84612     try {
84613       result = (arg1)->GetActorByFocusOrder(arg2);
84614     } catch (std::out_of_range& e) {
84615       {
84616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84617       };
84618     } catch (std::exception& e) {
84619       {
84620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84621       };
84622     } catch (Dali::DaliException e) {
84623       {
84624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84625       };
84626     } catch (...) {
84627       {
84628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84629       };
84630     }
84631   }
84632
84633   jresult = new Dali::Actor((const Dali::Actor &)result);
84634   return jresult;
84635 }
84636
84637
84638 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
84639   unsigned int jresult ;
84640   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84641   Dali::Actor arg2 ;
84642   Dali::Actor *argp2 ;
84643   bool result;
84644
84645   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84646   argp2 = (Dali::Actor *)jarg2;
84647   if (!argp2) {
84648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84649     return 0;
84650   }
84651   arg2 = *argp2;
84652   {
84653     try {
84654       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
84655     } catch (std::out_of_range& e) {
84656       {
84657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84658       };
84659     } catch (std::exception& e) {
84660       {
84661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84662       };
84663     } catch (Dali::DaliException e) {
84664       {
84665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84666       };
84667     } catch (...) {
84668       {
84669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84670       };
84671     }
84672   }
84673
84674   jresult = result;
84675   return jresult;
84676 }
84677
84678
84679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
84680   void * jresult ;
84681   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84682   Dali::Actor result;
84683
84684   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84685   {
84686     try {
84687       result = (arg1)->GetCurrentFocusActor();
84688     } catch (std::out_of_range& e) {
84689       {
84690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84691       };
84692     } catch (std::exception& e) {
84693       {
84694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84695       };
84696     } catch (Dali::DaliException e) {
84697       {
84698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84699       };
84700     } catch (...) {
84701       {
84702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84703       };
84704     }
84705   }
84706
84707   jresult = new Dali::Actor((const Dali::Actor &)result);
84708   return jresult;
84709 }
84710
84711
84712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
84713   void * jresult ;
84714   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84715   Dali::Actor result;
84716
84717   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84718   {
84719     try {
84720       result = (arg1)->GetCurrentFocusGroup();
84721     } catch (std::out_of_range& e) {
84722       {
84723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84724       };
84725     } catch (std::exception& e) {
84726       {
84727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84728       };
84729     } catch (Dali::DaliException e) {
84730       {
84731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84732       };
84733     } catch (...) {
84734       {
84735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84736       };
84737     }
84738   }
84739
84740   jresult = new Dali::Actor((const Dali::Actor &)result);
84741   return jresult;
84742 }
84743
84744
84745 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
84746   unsigned int jresult ;
84747   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84748   unsigned int result;
84749
84750   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84751   {
84752     try {
84753       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
84754     } catch (std::out_of_range& e) {
84755       {
84756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84757       };
84758     } catch (std::exception& e) {
84759       {
84760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84761       };
84762     } catch (Dali::DaliException e) {
84763       {
84764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84765       };
84766     } catch (...) {
84767       {
84768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84769       };
84770     }
84771   }
84772
84773   jresult = result;
84774   return jresult;
84775 }
84776
84777
84778 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
84779   unsigned int jresult ;
84780   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84781   bool result;
84782
84783   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84784   {
84785     try {
84786       result = (bool)(arg1)->MoveFocusForward();
84787     } catch (std::out_of_range& e) {
84788       {
84789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84790       };
84791     } catch (std::exception& e) {
84792       {
84793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84794       };
84795     } catch (Dali::DaliException e) {
84796       {
84797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84798       };
84799     } catch (...) {
84800       {
84801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84802       };
84803     }
84804   }
84805
84806   jresult = result;
84807   return jresult;
84808 }
84809
84810
84811 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
84812   unsigned int jresult ;
84813   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84814   bool result;
84815
84816   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84817   {
84818     try {
84819       result = (bool)(arg1)->MoveFocusBackward();
84820     } catch (std::out_of_range& e) {
84821       {
84822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84823       };
84824     } catch (std::exception& e) {
84825       {
84826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84827       };
84828     } catch (Dali::DaliException e) {
84829       {
84830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84831       };
84832     } catch (...) {
84833       {
84834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84835       };
84836     }
84837   }
84838
84839   jresult = result;
84840   return jresult;
84841 }
84842
84843
84844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
84845   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84846
84847   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84848   {
84849     try {
84850       (arg1)->ClearFocus();
84851     } catch (std::out_of_range& e) {
84852       {
84853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84854       };
84855     } catch (std::exception& e) {
84856       {
84857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84858       };
84859     } catch (Dali::DaliException e) {
84860       {
84861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84862       };
84863     } catch (...) {
84864       {
84865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84866       };
84867     }
84868   }
84869
84870 }
84871
84872
84873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
84874   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84875
84876   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84877   {
84878     try {
84879       (arg1)->Reset();
84880     } catch (std::out_of_range& e) {
84881       {
84882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84883       };
84884     } catch (std::exception& e) {
84885       {
84886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84887       };
84888     } catch (Dali::DaliException e) {
84889       {
84890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84891       };
84892     } catch (...) {
84893       {
84894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84895       };
84896     }
84897   }
84898
84899 }
84900
84901
84902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
84903   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84904   Dali::Actor arg2 ;
84905   bool arg3 ;
84906   Dali::Actor *argp2 ;
84907
84908   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84909   argp2 = (Dali::Actor *)jarg2;
84910   if (!argp2) {
84911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84912     return ;
84913   }
84914   arg2 = *argp2;
84915   arg3 = jarg3 ? true : false;
84916   {
84917     try {
84918       (arg1)->SetFocusGroup(arg2,arg3);
84919     } catch (std::out_of_range& e) {
84920       {
84921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84922       };
84923     } catch (std::exception& e) {
84924       {
84925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84926       };
84927     } catch (Dali::DaliException e) {
84928       {
84929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84930       };
84931     } catch (...) {
84932       {
84933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84934       };
84935     }
84936   }
84937
84938 }
84939
84940
84941 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
84942   unsigned int jresult ;
84943   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84944   Dali::Actor arg2 ;
84945   Dali::Actor *argp2 ;
84946   bool result;
84947
84948   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84949   argp2 = (Dali::Actor *)jarg2;
84950   if (!argp2) {
84951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84952     return 0;
84953   }
84954   arg2 = *argp2;
84955   {
84956     try {
84957       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
84958     } catch (std::out_of_range& e) {
84959       {
84960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84961       };
84962     } catch (std::exception& e) {
84963       {
84964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84965       };
84966     } catch (Dali::DaliException e) {
84967       {
84968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84969       };
84970     } catch (...) {
84971       {
84972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84973       };
84974     }
84975   }
84976
84977   jresult = result;
84978   return jresult;
84979 }
84980
84981
84982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
84983   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84984   bool arg2 ;
84985
84986   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84987   arg2 = jarg2 ? true : false;
84988   {
84989     try {
84990       (arg1)->SetGroupMode(arg2);
84991     } catch (std::out_of_range& e) {
84992       {
84993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84994       };
84995     } catch (std::exception& e) {
84996       {
84997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84998       };
84999     } catch (Dali::DaliException e) {
85000       {
85001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85002       };
85003     } catch (...) {
85004       {
85005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85006       };
85007     }
85008   }
85009
85010 }
85011
85012
85013 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
85014   unsigned int jresult ;
85015   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85016   bool result;
85017
85018   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85019   {
85020     try {
85021       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
85022     } catch (std::out_of_range& e) {
85023       {
85024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85025       };
85026     } catch (std::exception& e) {
85027       {
85028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85029       };
85030     } catch (Dali::DaliException e) {
85031       {
85032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85033       };
85034     } catch (...) {
85035       {
85036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85037       };
85038     }
85039   }
85040
85041   jresult = result;
85042   return jresult;
85043 }
85044
85045
85046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
85047   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85048   bool arg2 ;
85049
85050   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85051   arg2 = jarg2 ? true : false;
85052   {
85053     try {
85054       (arg1)->SetWrapMode(arg2);
85055     } catch (std::out_of_range& e) {
85056       {
85057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85058       };
85059     } catch (std::exception& e) {
85060       {
85061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85062       };
85063     } catch (Dali::DaliException e) {
85064       {
85065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85066       };
85067     } catch (...) {
85068       {
85069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85070       };
85071     }
85072   }
85073
85074 }
85075
85076
85077 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
85078   unsigned int jresult ;
85079   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85080   bool result;
85081
85082   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85083   {
85084     try {
85085       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
85086     } catch (std::out_of_range& e) {
85087       {
85088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85089       };
85090     } catch (std::exception& e) {
85091       {
85092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85093       };
85094     } catch (Dali::DaliException e) {
85095       {
85096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85097       };
85098     } catch (...) {
85099       {
85100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85101       };
85102     }
85103   }
85104
85105   jresult = result;
85106   return jresult;
85107 }
85108
85109
85110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
85111   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85112   Dali::Actor arg2 ;
85113   Dali::Actor *argp2 ;
85114
85115   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85116   argp2 = (Dali::Actor *)jarg2;
85117   if (!argp2) {
85118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85119     return ;
85120   }
85121   arg2 = *argp2;
85122   {
85123     try {
85124       (arg1)->SetFocusIndicatorActor(arg2);
85125     } catch (std::out_of_range& e) {
85126       {
85127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85128       };
85129     } catch (std::exception& e) {
85130       {
85131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85132       };
85133     } catch (Dali::DaliException e) {
85134       {
85135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85136       };
85137     } catch (...) {
85138       {
85139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85140       };
85141     }
85142   }
85143
85144 }
85145
85146
85147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
85148   void * jresult ;
85149   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85150   Dali::Actor result;
85151
85152   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85153   {
85154     try {
85155       result = (arg1)->GetFocusIndicatorActor();
85156     } catch (std::out_of_range& e) {
85157       {
85158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85159       };
85160     } catch (std::exception& e) {
85161       {
85162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85163       };
85164     } catch (Dali::DaliException e) {
85165       {
85166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85167       };
85168     } catch (...) {
85169       {
85170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85171       };
85172     }
85173   }
85174
85175   jresult = new Dali::Actor((const Dali::Actor &)result);
85176   return jresult;
85177 }
85178
85179
85180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
85181   void * jresult ;
85182   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85183   Dali::Actor arg2 ;
85184   Dali::Actor *argp2 ;
85185   Dali::Actor result;
85186
85187   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85188   argp2 = (Dali::Actor *)jarg2;
85189   if (!argp2) {
85190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85191     return 0;
85192   }
85193   arg2 = *argp2;
85194   {
85195     try {
85196       result = (arg1)->GetFocusGroup(arg2);
85197     } catch (std::out_of_range& e) {
85198       {
85199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85200       };
85201     } catch (std::exception& e) {
85202       {
85203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85204       };
85205     } catch (Dali::DaliException e) {
85206       {
85207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85208       };
85209     } catch (...) {
85210       {
85211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85212       };
85213     }
85214   }
85215
85216   jresult = new Dali::Actor((const Dali::Actor &)result);
85217   return jresult;
85218 }
85219
85220
85221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
85222   void * jresult ;
85223   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85224   Dali::Vector2 result;
85225
85226   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85227   {
85228     try {
85229       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
85230     } catch (std::out_of_range& e) {
85231       {
85232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85233       };
85234     } catch (std::exception& e) {
85235       {
85236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85237       };
85238     } catch (Dali::DaliException e) {
85239       {
85240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85241       };
85242     } catch (...) {
85243       {
85244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85245       };
85246     }
85247   }
85248
85249   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
85250   return jresult;
85251 }
85252
85253
85254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
85255   void * jresult ;
85256   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85257   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
85258
85259   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85260   {
85261     try {
85262       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
85263     } catch (std::out_of_range& e) {
85264       {
85265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85266       };
85267     } catch (std::exception& e) {
85268       {
85269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85270       };
85271     } catch (Dali::DaliException e) {
85272       {
85273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85274       };
85275     } catch (...) {
85276       {
85277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85278       };
85279     }
85280   }
85281
85282   jresult = (void *)result;
85283   return jresult;
85284 }
85285
85286
85287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
85288   void * jresult ;
85289   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85290   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
85291
85292   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85293   {
85294     try {
85295       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
85296     } catch (std::out_of_range& e) {
85297       {
85298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85299       };
85300     } catch (std::exception& e) {
85301       {
85302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85303       };
85304     } catch (Dali::DaliException e) {
85305       {
85306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85307       };
85308     } catch (...) {
85309       {
85310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85311       };
85312     }
85313   }
85314
85315   jresult = (void *)result;
85316   return jresult;
85317 }
85318
85319
85320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
85321   void * jresult ;
85322   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85323   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
85324
85325   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85326   {
85327     try {
85328       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
85329     } catch (std::out_of_range& e) {
85330       {
85331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85332       };
85333     } catch (std::exception& e) {
85334       {
85335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85336       };
85337     } catch (Dali::DaliException e) {
85338       {
85339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85340       };
85341     } catch (...) {
85342       {
85343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85344       };
85345     }
85346   }
85347
85348   jresult = (void *)result;
85349   return jresult;
85350 }
85351
85352
85353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
85354   void * jresult ;
85355   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85356   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85357
85358   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85359   {
85360     try {
85361       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
85362     } catch (std::out_of_range& e) {
85363       {
85364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85365       };
85366     } catch (std::exception& e) {
85367       {
85368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85369       };
85370     } catch (Dali::DaliException e) {
85371       {
85372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85373       };
85374     } catch (...) {
85375       {
85376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85377       };
85378     }
85379   }
85380
85381   jresult = (void *)result;
85382   return jresult;
85383 }
85384
85385
85386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
85387   void * jresult ;
85388   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85389   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85390
85391   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85392   {
85393     try {
85394       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
85395     } catch (std::out_of_range& e) {
85396       {
85397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85398       };
85399     } catch (std::exception& e) {
85400       {
85401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85402       };
85403     } catch (Dali::DaliException e) {
85404       {
85405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85406       };
85407     } catch (...) {
85408       {
85409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85410       };
85411     }
85412   }
85413
85414   jresult = (void *)result;
85415   return jresult;
85416 }
85417
85418
85419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
85420   void * jresult ;
85421   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85422   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85423
85424   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85425   {
85426     try {
85427       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
85428     } catch (std::out_of_range& e) {
85429       {
85430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85431       };
85432     } catch (std::exception& e) {
85433       {
85434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85435       };
85436     } catch (Dali::DaliException e) {
85437       {
85438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85439       };
85440     } catch (...) {
85441       {
85442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85443       };
85444     }
85445   }
85446
85447   jresult = (void *)result;
85448   return jresult;
85449 }
85450
85451
85452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
85453   void * jresult ;
85454   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85455   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85456
85457   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85458   {
85459     try {
85460       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
85461     } catch (std::out_of_range& e) {
85462       {
85463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85464       };
85465     } catch (std::exception& e) {
85466       {
85467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85468       };
85469     } catch (Dali::DaliException e) {
85470       {
85471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85472       };
85473     } catch (...) {
85474       {
85475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85476       };
85477     }
85478   }
85479
85480   jresult = (void *)result;
85481   return jresult;
85482 }
85483
85484
85485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
85486   void * jresult ;
85487   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85488   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85489
85490   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85491   {
85492     try {
85493       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
85494     } catch (std::out_of_range& e) {
85495       {
85496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85497       };
85498     } catch (std::exception& e) {
85499       {
85500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85501       };
85502     } catch (Dali::DaliException e) {
85503       {
85504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85505       };
85506     } catch (...) {
85507       {
85508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85509       };
85510     }
85511   }
85512
85513   jresult = (void *)result;
85514   return jresult;
85515 }
85516
85517
85518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
85519   void * jresult ;
85520   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85521   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85522
85523   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85524   {
85525     try {
85526       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
85527     } catch (std::out_of_range& e) {
85528       {
85529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85530       };
85531     } catch (std::exception& e) {
85532       {
85533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85534       };
85535     } catch (Dali::DaliException e) {
85536       {
85537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85538       };
85539     } catch (...) {
85540       {
85541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85542       };
85543     }
85544   }
85545
85546   jresult = (void *)result;
85547   return jresult;
85548 }
85549
85550
85551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
85552   void * jresult ;
85553   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85554   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85555
85556   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85557   {
85558     try {
85559       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
85560     } catch (std::out_of_range& e) {
85561       {
85562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85563       };
85564     } catch (std::exception& e) {
85565       {
85566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85567       };
85568     } catch (Dali::DaliException e) {
85569       {
85570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85571       };
85572     } catch (...) {
85573       {
85574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85575       };
85576     }
85577   }
85578
85579   jresult = (void *)result;
85580   return jresult;
85581 }
85582
85583
85584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
85585   void * jresult ;
85586   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85587   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85588
85589   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85590   {
85591     try {
85592       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
85593     } catch (std::out_of_range& e) {
85594       {
85595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85596       };
85597     } catch (std::exception& e) {
85598       {
85599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85600       };
85601     } catch (Dali::DaliException e) {
85602       {
85603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85604       };
85605     } catch (...) {
85606       {
85607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85608       };
85609     }
85610   }
85611
85612   jresult = (void *)result;
85613   return jresult;
85614 }
85615
85616
85617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
85618   void * jresult ;
85619   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85620   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85621
85622   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85623   {
85624     try {
85625       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
85626     } catch (std::out_of_range& e) {
85627       {
85628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85629       };
85630     } catch (std::exception& e) {
85631       {
85632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85633       };
85634     } catch (Dali::DaliException e) {
85635       {
85636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85637       };
85638     } catch (...) {
85639       {
85640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85641       };
85642     }
85643   }
85644
85645   jresult = (void *)result;
85646   return jresult;
85647 }
85648
85649
85650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
85651   void * jresult ;
85652   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85653   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85654
85655   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85656   {
85657     try {
85658       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
85659     } catch (std::out_of_range& e) {
85660       {
85661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85662       };
85663     } catch (std::exception& e) {
85664       {
85665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85666       };
85667     } catch (Dali::DaliException e) {
85668       {
85669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85670       };
85671     } catch (...) {
85672       {
85673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85674       };
85675     }
85676   }
85677
85678   jresult = (void *)result;
85679   return jresult;
85680 }
85681
85682
85683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
85684   void * jresult ;
85685   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85686   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85687
85688   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85689   {
85690     try {
85691       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
85692     } catch (std::out_of_range& e) {
85693       {
85694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85695       };
85696     } catch (std::exception& e) {
85697       {
85698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85699       };
85700     } catch (Dali::DaliException e) {
85701       {
85702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85703       };
85704     } catch (...) {
85705       {
85706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85707       };
85708     }
85709   }
85710
85711   jresult = (void *)result;
85712   return jresult;
85713 }
85714
85715
85716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
85717   void * jresult ;
85718   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85719   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85720
85721   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85722   {
85723     try {
85724       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
85725     } catch (std::out_of_range& e) {
85726       {
85727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85728       };
85729     } catch (std::exception& e) {
85730       {
85731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85732       };
85733     } catch (Dali::DaliException e) {
85734       {
85735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85736       };
85737     } catch (...) {
85738       {
85739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85740       };
85741     }
85742   }
85743
85744   jresult = (void *)result;
85745   return jresult;
85746 }
85747
85748
85749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
85750   void * jresult ;
85751   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85752   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85753
85754   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85755   {
85756     try {
85757       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
85758     } catch (std::out_of_range& e) {
85759       {
85760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85761       };
85762     } catch (std::exception& e) {
85763       {
85764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85765       };
85766     } catch (Dali::DaliException e) {
85767       {
85768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85769       };
85770     } catch (...) {
85771       {
85772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85773       };
85774     }
85775   }
85776
85777   jresult = (void *)result;
85778   return jresult;
85779 }
85780
85781
85782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
85783   void * jresult ;
85784   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85785   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85786
85787   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85788   {
85789     try {
85790       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
85791     } catch (std::out_of_range& e) {
85792       {
85793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85794       };
85795     } catch (std::exception& e) {
85796       {
85797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85798       };
85799     } catch (Dali::DaliException e) {
85800       {
85801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85802       };
85803     } catch (...) {
85804       {
85805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85806       };
85807     }
85808   }
85809
85810   jresult = (void *)result;
85811   return jresult;
85812 }
85813
85814
85815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
85816   void * jresult ;
85817   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85818   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85819
85820   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85821   {
85822     try {
85823       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
85824     } catch (std::out_of_range& e) {
85825       {
85826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85827       };
85828     } catch (std::exception& e) {
85829       {
85830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85831       };
85832     } catch (Dali::DaliException e) {
85833       {
85834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85835       };
85836     } catch (...) {
85837       {
85838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85839       };
85840     }
85841   }
85842
85843   jresult = (void *)result;
85844   return jresult;
85845 }
85846
85847
85848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
85849   void * jresult ;
85850   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85851   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85852
85853   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85854   {
85855     try {
85856       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
85857     } catch (std::out_of_range& e) {
85858       {
85859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85860       };
85861     } catch (std::exception& e) {
85862       {
85863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85864       };
85865     } catch (Dali::DaliException e) {
85866       {
85867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85868       };
85869     } catch (...) {
85870       {
85871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85872       };
85873     }
85874   }
85875
85876   jresult = (void *)result;
85877   return jresult;
85878 }
85879
85880
85881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
85882   void * jresult ;
85883   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85884   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85885
85886   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85887   {
85888     try {
85889       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
85890     } catch (std::out_of_range& e) {
85891       {
85892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85893       };
85894     } catch (std::exception& e) {
85895       {
85896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85897       };
85898     } catch (Dali::DaliException e) {
85899       {
85900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85901       };
85902     } catch (...) {
85903       {
85904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85905       };
85906     }
85907   }
85908
85909   jresult = (void *)result;
85910   return jresult;
85911 }
85912
85913
85914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
85915   void * jresult ;
85916   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85917   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85918
85919   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85920   {
85921     try {
85922       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
85923     } catch (std::out_of_range& e) {
85924       {
85925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85926       };
85927     } catch (std::exception& e) {
85928       {
85929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85930       };
85931     } catch (Dali::DaliException e) {
85932       {
85933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85934       };
85935     } catch (...) {
85936       {
85937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85938       };
85939     }
85940   }
85941
85942   jresult = (void *)result;
85943   return jresult;
85944 }
85945
85946
85947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
85948   void * jresult ;
85949   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85950   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85951
85952   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85953   {
85954     try {
85955       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
85956     } catch (std::out_of_range& e) {
85957       {
85958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85959       };
85960     } catch (std::exception& e) {
85961       {
85962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85963       };
85964     } catch (Dali::DaliException e) {
85965       {
85966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85967       };
85968     } catch (...) {
85969       {
85970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85971       };
85972     }
85973   }
85974
85975   jresult = (void *)result;
85976   return jresult;
85977 }
85978
85979
85980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
85981   void * jresult ;
85982   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85983   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85984
85985   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85986   {
85987     try {
85988       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
85989     } catch (std::out_of_range& e) {
85990       {
85991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85992       };
85993     } catch (std::exception& e) {
85994       {
85995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85996       };
85997     } catch (Dali::DaliException e) {
85998       {
85999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86000       };
86001     } catch (...) {
86002       {
86003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86004       };
86005     }
86006   }
86007
86008   jresult = (void *)result;
86009   return jresult;
86010 }
86011
86012
86013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
86014   void * jresult ;
86015   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86016   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86017
86018   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86019   {
86020     try {
86021       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
86022     } catch (std::out_of_range& e) {
86023       {
86024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86025       };
86026     } catch (std::exception& e) {
86027       {
86028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86029       };
86030     } catch (Dali::DaliException e) {
86031       {
86032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86033       };
86034     } catch (...) {
86035       {
86036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86037       };
86038     }
86039   }
86040
86041   jresult = (void *)result;
86042   return jresult;
86043 }
86044
86045
86046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
86047   void * jresult ;
86048   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86049   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86050
86051   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86052   {
86053     try {
86054       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
86055     } catch (std::out_of_range& e) {
86056       {
86057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86058       };
86059     } catch (std::exception& e) {
86060       {
86061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86062       };
86063     } catch (Dali::DaliException e) {
86064       {
86065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86066       };
86067     } catch (...) {
86068       {
86069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86070       };
86071     }
86072   }
86073
86074   jresult = (void *)result;
86075   return jresult;
86076 }
86077
86078
86079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
86080   void * jresult ;
86081   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86082   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86083
86084   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86085   {
86086     try {
86087       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
86088     } catch (std::out_of_range& e) {
86089       {
86090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86091       };
86092     } catch (std::exception& e) {
86093       {
86094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86095       };
86096     } catch (Dali::DaliException e) {
86097       {
86098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86099       };
86100     } catch (...) {
86101       {
86102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86103       };
86104     }
86105   }
86106
86107   jresult = (void *)result;
86108   return jresult;
86109 }
86110
86111
86112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
86113   void * jresult ;
86114   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86115   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86116
86117   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86118   {
86119     try {
86120       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
86121     } catch (std::out_of_range& e) {
86122       {
86123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86124       };
86125     } catch (std::exception& e) {
86126       {
86127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86128       };
86129     } catch (Dali::DaliException e) {
86130       {
86131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86132       };
86133     } catch (...) {
86134       {
86135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86136       };
86137     }
86138   }
86139
86140   jresult = (void *)result;
86141   return jresult;
86142 }
86143
86144
86145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
86146   void * jresult ;
86147   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86148   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86149
86150   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86151   {
86152     try {
86153       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
86154     } catch (std::out_of_range& e) {
86155       {
86156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86157       };
86158     } catch (std::exception& e) {
86159       {
86160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86161       };
86162     } catch (Dali::DaliException e) {
86163       {
86164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86165       };
86166     } catch (...) {
86167       {
86168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86169       };
86170     }
86171   }
86172
86173   jresult = (void *)result;
86174   return jresult;
86175 }
86176
86177
86178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
86179   void * jresult ;
86180   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86181   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86182
86183   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86184   {
86185     try {
86186       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
86187     } catch (std::out_of_range& e) {
86188       {
86189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86190       };
86191     } catch (std::exception& e) {
86192       {
86193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86194       };
86195     } catch (Dali::DaliException e) {
86196       {
86197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86198       };
86199     } catch (...) {
86200       {
86201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86202       };
86203     }
86204   }
86205
86206   jresult = (void *)result;
86207   return jresult;
86208 }
86209
86210
86211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
86212   void * jresult ;
86213   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86214   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
86215
86216   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86217   {
86218     try {
86219       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
86220     } catch (std::out_of_range& e) {
86221       {
86222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86223       };
86224     } catch (std::exception& e) {
86225       {
86226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86227       };
86228     } catch (Dali::DaliException e) {
86229       {
86230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86231       };
86232     } catch (...) {
86233       {
86234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86235       };
86236     }
86237   }
86238
86239   jresult = (void *)result;
86240   return jresult;
86241 }
86242
86243
86244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
86245   void * jresult ;
86246   Dali::Toolkit::StyleManager *result = 0 ;
86247
86248   {
86249     try {
86250       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
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_delete_StyleManager(void * jarg1) {
86276   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86277
86278   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86279   {
86280     try {
86281       delete arg1;
86282     } catch (std::out_of_range& e) {
86283       {
86284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86285       };
86286     } catch (std::exception& e) {
86287       {
86288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86289       };
86290     } catch (Dali::DaliException e) {
86291       {
86292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86293       };
86294     } catch (...) {
86295       {
86296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86297       };
86298     }
86299   }
86300
86301 }
86302
86303
86304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
86305   void * jresult ;
86306   Dali::Toolkit::StyleManager result;
86307
86308   {
86309     try {
86310       result = Dali::Toolkit::StyleManager::Get();
86311     } catch (std::out_of_range& e) {
86312       {
86313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86314       };
86315     } catch (std::exception& e) {
86316       {
86317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86318       };
86319     } catch (Dali::DaliException e) {
86320       {
86321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86322       };
86323     } catch (...) {
86324       {
86325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86326       };
86327     }
86328   }
86329
86330   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
86331   return jresult;
86332 }
86333
86334
86335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
86336   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86337   std::string *arg2 = 0 ;
86338
86339   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86340   if (!jarg2) {
86341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86342     return ;
86343   }
86344   std::string arg2_str(jarg2);
86345   arg2 = &arg2_str;
86346   {
86347     try {
86348       (arg1)->ApplyTheme((std::string const &)*arg2);
86349     } catch (std::out_of_range& e) {
86350       {
86351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86352       };
86353     } catch (std::exception& e) {
86354       {
86355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86356       };
86357     } catch (Dali::DaliException e) {
86358       {
86359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86360       };
86361     } catch (...) {
86362       {
86363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86364       };
86365     }
86366   }
86367
86368
86369   //argout typemap for const std::string&
86370
86371 }
86372
86373
86374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
86375   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86376
86377   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86378   {
86379     try {
86380       (arg1)->ApplyDefaultTheme();
86381     } catch (std::out_of_range& e) {
86382       {
86383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86384       };
86385     } catch (std::exception& e) {
86386       {
86387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86388       };
86389     } catch (Dali::DaliException e) {
86390       {
86391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86392       };
86393     } catch (...) {
86394       {
86395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86396       };
86397     }
86398   }
86399
86400 }
86401
86402
86403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86404   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86405   std::string *arg2 = 0 ;
86406   Dali::Property::Value *arg3 = 0 ;
86407
86408   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86409   if (!jarg2) {
86410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86411     return ;
86412   }
86413   std::string arg2_str(jarg2);
86414   arg2 = &arg2_str;
86415   arg3 = (Dali::Property::Value *)jarg3;
86416   if (!arg3) {
86417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
86418     return ;
86419   }
86420   {
86421     try {
86422       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
86423     } catch (std::out_of_range& e) {
86424       {
86425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86426       };
86427     } catch (std::exception& e) {
86428       {
86429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86430       };
86431     } catch (Dali::DaliException e) {
86432       {
86433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86434       };
86435     } catch (...) {
86436       {
86437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86438       };
86439     }
86440   }
86441
86442
86443   //argout typemap for const std::string&
86444
86445 }
86446
86447
86448 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86449   unsigned int jresult ;
86450   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86451   std::string *arg2 = 0 ;
86452   Dali::Property::Value *arg3 = 0 ;
86453   bool result;
86454
86455   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86456   if (!jarg2) {
86457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86458     return 0;
86459   }
86460   std::string arg2_str(jarg2);
86461   arg2 = &arg2_str;
86462   arg3 = (Dali::Property::Value *)jarg3;
86463   if (!arg3) {
86464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
86465     return 0;
86466   }
86467   {
86468     try {
86469       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
86470     } catch (std::out_of_range& e) {
86471       {
86472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86473       };
86474     } catch (std::exception& e) {
86475       {
86476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86477       };
86478     } catch (Dali::DaliException e) {
86479       {
86480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86481       };
86482     } catch (...) {
86483       {
86484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86485       };
86486     }
86487   }
86488
86489   jresult = result;
86490
86491   //argout typemap for const std::string&
86492
86493   return jresult;
86494 }
86495
86496
86497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
86498   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86499   Dali::Toolkit::Control arg2 ;
86500   std::string *arg3 = 0 ;
86501   std::string *arg4 = 0 ;
86502   Dali::Toolkit::Control *argp2 ;
86503
86504   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86505   argp2 = (Dali::Toolkit::Control *)jarg2;
86506   if (!argp2) {
86507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
86508     return ;
86509   }
86510   arg2 = *argp2;
86511   if (!jarg3) {
86512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86513     return ;
86514   }
86515   std::string arg3_str(jarg3);
86516   arg3 = &arg3_str;
86517   if (!jarg4) {
86518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86519     return ;
86520   }
86521   std::string arg4_str(jarg4);
86522   arg4 = &arg4_str;
86523   {
86524     try {
86525       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
86526     } catch (std::out_of_range& e) {
86527       {
86528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86529       };
86530     } catch (std::exception& e) {
86531       {
86532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86533       };
86534     } catch (Dali::DaliException e) {
86535       {
86536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86537       };
86538     } catch (...) {
86539       {
86540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86541       };
86542     }
86543   }
86544
86545
86546   //argout typemap for const std::string&
86547
86548
86549   //argout typemap for const std::string&
86550
86551 }
86552
86553
86554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
86555   void * jresult ;
86556   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86557   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
86558
86559   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86560   {
86561     try {
86562       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
86563     } catch (std::out_of_range& e) {
86564       {
86565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86566       };
86567     } catch (std::exception& e) {
86568       {
86569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86570       };
86571     } catch (Dali::DaliException e) {
86572       {
86573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86574       };
86575     } catch (...) {
86576       {
86577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86578       };
86579     }
86580   }
86581
86582   jresult = (void *)result;
86583   return jresult;
86584 }
86585
86586
86587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
86588   int jresult ;
86589   int result;
86590
86591   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
86592   jresult = (int)result;
86593   return jresult;
86594 }
86595
86596
86597 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
86598   int jresult ;
86599   int result;
86600
86601   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
86602   jresult = (int)result;
86603   return jresult;
86604 }
86605
86606
86607 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
86608   int jresult ;
86609   int result;
86610
86611   result = (int)Dali::Toolkit::Slider::Property::VALUE;
86612   jresult = (int)result;
86613   return jresult;
86614 }
86615
86616
86617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
86618   int jresult ;
86619   int result;
86620
86621   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
86622   jresult = (int)result;
86623   return jresult;
86624 }
86625
86626
86627 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
86628   int jresult ;
86629   int result;
86630
86631   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
86632   jresult = (int)result;
86633   return jresult;
86634 }
86635
86636
86637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
86638   int jresult ;
86639   int result;
86640
86641   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
86642   jresult = (int)result;
86643   return jresult;
86644 }
86645
86646
86647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
86648   int jresult ;
86649   int result;
86650
86651   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
86652   jresult = (int)result;
86653   return jresult;
86654 }
86655
86656
86657 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
86658   int jresult ;
86659   int result;
86660
86661   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
86662   jresult = (int)result;
86663   return jresult;
86664 }
86665
86666
86667 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
86668   int jresult ;
86669   int result;
86670
86671   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
86672   jresult = (int)result;
86673   return jresult;
86674 }
86675
86676
86677 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
86678   int jresult ;
86679   int result;
86680
86681   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
86682   jresult = (int)result;
86683   return jresult;
86684 }
86685
86686
86687 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
86688   int jresult ;
86689   int result;
86690
86691   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
86692   jresult = (int)result;
86693   return jresult;
86694 }
86695
86696
86697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
86698   int jresult ;
86699   int result;
86700
86701   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
86702   jresult = (int)result;
86703   return jresult;
86704 }
86705
86706
86707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
86708   int jresult ;
86709   int result;
86710
86711   result = (int)Dali::Toolkit::Slider::Property::MARKS;
86712   jresult = (int)result;
86713   return jresult;
86714 }
86715
86716
86717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
86718   int jresult ;
86719   int result;
86720
86721   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
86722   jresult = (int)result;
86723   return jresult;
86724 }
86725
86726
86727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
86728   int jresult ;
86729   int result;
86730
86731   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
86732   jresult = (int)result;
86733   return jresult;
86734 }
86735
86736
86737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
86738   void * jresult ;
86739   Dali::Toolkit::Slider::Property *result = 0 ;
86740
86741   {
86742     try {
86743       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
86744     } catch (std::out_of_range& e) {
86745       {
86746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86747       };
86748     } catch (std::exception& e) {
86749       {
86750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86751       };
86752     } catch (Dali::DaliException e) {
86753       {
86754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86755       };
86756     } catch (...) {
86757       {
86758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86759       };
86760     }
86761   }
86762
86763   jresult = (void *)result;
86764   return jresult;
86765 }
86766
86767
86768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
86769   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
86770
86771   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
86772   {
86773     try {
86774       delete arg1;
86775     } catch (std::out_of_range& e) {
86776       {
86777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86778       };
86779     } catch (std::exception& e) {
86780       {
86781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86782       };
86783     } catch (Dali::DaliException e) {
86784       {
86785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86786       };
86787     } catch (...) {
86788       {
86789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86790       };
86791     }
86792   }
86793
86794 }
86795
86796
86797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
86798   void * jresult ;
86799   Dali::Toolkit::Slider result;
86800
86801   {
86802     try {
86803       result = Dali::Toolkit::Slider::New();
86804     } catch (std::out_of_range& e) {
86805       {
86806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86807       };
86808     } catch (std::exception& e) {
86809       {
86810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86811       };
86812     } catch (Dali::DaliException e) {
86813       {
86814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86815       };
86816     } catch (...) {
86817       {
86818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86819       };
86820     }
86821   }
86822
86823   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
86824   return jresult;
86825 }
86826
86827
86828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
86829   void * jresult ;
86830   Dali::Toolkit::Slider *result = 0 ;
86831
86832   {
86833     try {
86834       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
86835     } catch (std::out_of_range& e) {
86836       {
86837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86838       };
86839     } catch (std::exception& e) {
86840       {
86841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86842       };
86843     } catch (Dali::DaliException e) {
86844       {
86845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86846       };
86847     } catch (...) {
86848       {
86849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86850       };
86851     }
86852   }
86853
86854   jresult = (void *)result;
86855   return jresult;
86856 }
86857
86858
86859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
86860   void * jresult ;
86861   Dali::Toolkit::Slider *arg1 = 0 ;
86862   Dali::Toolkit::Slider *result = 0 ;
86863
86864   arg1 = (Dali::Toolkit::Slider *)jarg1;
86865   if (!arg1) {
86866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
86867     return 0;
86868   }
86869   {
86870     try {
86871       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
86872     } catch (std::out_of_range& e) {
86873       {
86874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86875       };
86876     } catch (std::exception& e) {
86877       {
86878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86879       };
86880     } catch (Dali::DaliException e) {
86881       {
86882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86883       };
86884     } catch (...) {
86885       {
86886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86887       };
86888     }
86889   }
86890
86891   jresult = (void *)result;
86892   return jresult;
86893 }
86894
86895
86896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
86897   void * jresult ;
86898   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86899   Dali::Toolkit::Slider *arg2 = 0 ;
86900   Dali::Toolkit::Slider *result = 0 ;
86901
86902   arg1 = (Dali::Toolkit::Slider *)jarg1;
86903   arg2 = (Dali::Toolkit::Slider *)jarg2;
86904   if (!arg2) {
86905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
86906     return 0;
86907   }
86908   {
86909     try {
86910       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
86911     } catch (std::out_of_range& e) {
86912       {
86913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86914       };
86915     } catch (std::exception& e) {
86916       {
86917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86918       };
86919     } catch (Dali::DaliException e) {
86920       {
86921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86922       };
86923     } catch (...) {
86924       {
86925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86926       };
86927     }
86928   }
86929
86930   jresult = (void *)result;
86931   return jresult;
86932 }
86933
86934
86935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
86936   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86937
86938   arg1 = (Dali::Toolkit::Slider *)jarg1;
86939   {
86940     try {
86941       delete arg1;
86942     } catch (std::out_of_range& e) {
86943       {
86944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86945       };
86946     } catch (std::exception& e) {
86947       {
86948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86949       };
86950     } catch (Dali::DaliException e) {
86951       {
86952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86953       };
86954     } catch (...) {
86955       {
86956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86957       };
86958     }
86959   }
86960
86961 }
86962
86963
86964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
86965   void * jresult ;
86966   Dali::BaseHandle arg1 ;
86967   Dali::BaseHandle *argp1 ;
86968   Dali::Toolkit::Slider result;
86969
86970   argp1 = (Dali::BaseHandle *)jarg1;
86971   if (!argp1) {
86972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86973     return 0;
86974   }
86975   arg1 = *argp1;
86976   {
86977     try {
86978       result = Dali::Toolkit::Slider::DownCast(arg1);
86979     } catch (std::out_of_range& e) {
86980       {
86981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86982       };
86983     } catch (std::exception& e) {
86984       {
86985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86986       };
86987     } catch (Dali::DaliException e) {
86988       {
86989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86990       };
86991     } catch (...) {
86992       {
86993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86994       };
86995     }
86996   }
86997
86998   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
86999   return jresult;
87000 }
87001
87002
87003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
87004   void * jresult ;
87005   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87006   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
87007
87008   arg1 = (Dali::Toolkit::Slider *)jarg1;
87009   {
87010     try {
87011       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
87012     } catch (std::out_of_range& e) {
87013       {
87014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87015       };
87016     } catch (std::exception& e) {
87017       {
87018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87019       };
87020     } catch (Dali::DaliException e) {
87021       {
87022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87023       };
87024     } catch (...) {
87025       {
87026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87027       };
87028     }
87029   }
87030
87031   jresult = (void *)result;
87032   return jresult;
87033 }
87034
87035
87036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
87037   void * jresult ;
87038   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87039   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
87040
87041   arg1 = (Dali::Toolkit::Slider *)jarg1;
87042   {
87043     try {
87044       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
87045     } catch (std::out_of_range& e) {
87046       {
87047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87048       };
87049     } catch (std::exception& e) {
87050       {
87051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87052       };
87053     } catch (Dali::DaliException e) {
87054       {
87055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87056       };
87057     } catch (...) {
87058       {
87059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87060       };
87061     }
87062   }
87063
87064   jresult = (void *)result;
87065   return jresult;
87066 }
87067
87068
87069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
87070   void * jresult ;
87071   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87072   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
87073
87074   arg1 = (Dali::Toolkit::Slider *)jarg1;
87075   {
87076     try {
87077       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
87078     } catch (std::out_of_range& e) {
87079       {
87080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87081       };
87082     } catch (std::exception& e) {
87083       {
87084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87085       };
87086     } catch (Dali::DaliException e) {
87087       {
87088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87089       };
87090     } catch (...) {
87091       {
87092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87093       };
87094     }
87095   }
87096
87097   jresult = (void *)result;
87098   return jresult;
87099 }
87100
87101
87102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
87103   int jresult ;
87104   int result;
87105
87106   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
87107   jresult = (int)result;
87108   return jresult;
87109 }
87110
87111
87112 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
87113   int jresult ;
87114   int result;
87115
87116   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
87117   jresult = (int)result;
87118   return jresult;
87119 }
87120
87121
87122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
87123   int jresult ;
87124   int result;
87125
87126   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
87127   jresult = (int)result;
87128   return jresult;
87129 }
87130
87131
87132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
87133   int jresult ;
87134   int result;
87135
87136   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
87137   jresult = (int)result;
87138   return jresult;
87139 }
87140
87141
87142 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
87143   int result;
87144
87145   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
87146
87147   return result;
87148 }
87149
87150
87151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
87152   void * jresult ;
87153   Dali::Toolkit::VideoView::Property *result = 0 ;
87154
87155   {
87156     try {
87157       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
87158     } catch (std::out_of_range& e) {
87159       {
87160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87161       };
87162     } catch (std::exception& e) {
87163       {
87164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87165       };
87166     } catch (Dali::DaliException e) {
87167       {
87168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87169       };
87170     } catch (...) {
87171       {
87172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87173       };
87174     }
87175   }
87176
87177   jresult = (void *)result;
87178   return jresult;
87179 }
87180
87181
87182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
87183   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
87184
87185   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
87186   {
87187     try {
87188       delete arg1;
87189     } catch (std::out_of_range& e) {
87190       {
87191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87192       };
87193     } catch (std::exception& e) {
87194       {
87195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87196       };
87197     } catch (Dali::DaliException e) {
87198       {
87199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87200       };
87201     } catch (...) {
87202       {
87203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87204       };
87205     }
87206   }
87207
87208 }
87209
87210
87211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
87212   void * jresult ;
87213   Dali::Toolkit::VideoView result;
87214
87215   {
87216     try {
87217       result = Dali::Toolkit::VideoView::New();
87218     } catch (std::out_of_range& e) {
87219       {
87220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87221       };
87222     } catch (std::exception& e) {
87223       {
87224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87225       };
87226     } catch (Dali::DaliException e) {
87227       {
87228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87229       };
87230     } catch (...) {
87231       {
87232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87233       };
87234     }
87235   }
87236
87237   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87238   return jresult;
87239 }
87240
87241
87242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
87243   void * jresult ;
87244   std::string *arg1 = 0 ;
87245   Dali::Toolkit::VideoView result;
87246
87247   if (!jarg1) {
87248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87249     return 0;
87250   }
87251   std::string arg1_str(jarg1);
87252   arg1 = &arg1_str;
87253   {
87254     try {
87255       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
87256     } catch (std::out_of_range& e) {
87257       {
87258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87259       };
87260     } catch (std::exception& e) {
87261       {
87262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87263       };
87264     } catch (Dali::DaliException e) {
87265       {
87266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87267       };
87268     } catch (...) {
87269       {
87270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87271       };
87272     }
87273   }
87274
87275   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87276
87277   //argout typemap for const std::string&
87278
87279   return jresult;
87280 }
87281
87282
87283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
87284   void * jresult ;
87285   Dali::Toolkit::VideoView *result = 0 ;
87286
87287   {
87288     try {
87289       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
87290     } catch (std::out_of_range& e) {
87291       {
87292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87293       };
87294     } catch (std::exception& e) {
87295       {
87296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87297       };
87298     } catch (Dali::DaliException e) {
87299       {
87300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87301       };
87302     } catch (...) {
87303       {
87304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87305       };
87306     }
87307   }
87308
87309   jresult = (void *)result;
87310   return jresult;
87311 }
87312
87313
87314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
87315   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87316
87317   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87318   {
87319     try {
87320       delete arg1;
87321     } catch (std::out_of_range& e) {
87322       {
87323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87324       };
87325     } catch (std::exception& e) {
87326       {
87327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87328       };
87329     } catch (Dali::DaliException e) {
87330       {
87331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87332       };
87333     } catch (...) {
87334       {
87335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87336       };
87337     }
87338   }
87339
87340 }
87341
87342
87343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
87344   void * jresult ;
87345   Dali::Toolkit::VideoView *arg1 = 0 ;
87346   Dali::Toolkit::VideoView *result = 0 ;
87347
87348   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87349   if (!arg1) {
87350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87351     return 0;
87352   }
87353   {
87354     try {
87355       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
87356     } catch (std::out_of_range& e) {
87357       {
87358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87359       };
87360     } catch (std::exception& e) {
87361       {
87362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87363       };
87364     } catch (Dali::DaliException e) {
87365       {
87366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87367       };
87368     } catch (...) {
87369       {
87370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87371       };
87372     }
87373   }
87374
87375   jresult = (void *)result;
87376   return jresult;
87377 }
87378
87379
87380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
87381   void * jresult ;
87382   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87383   Dali::Toolkit::VideoView *arg2 = 0 ;
87384   Dali::Toolkit::VideoView *result = 0 ;
87385
87386   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87387   arg2 = (Dali::Toolkit::VideoView *)jarg2;
87388   if (!arg2) {
87389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87390     return 0;
87391   }
87392   {
87393     try {
87394       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
87395     } catch (std::out_of_range& e) {
87396       {
87397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87398       };
87399     } catch (std::exception& e) {
87400       {
87401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87402       };
87403     } catch (Dali::DaliException e) {
87404       {
87405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87406       };
87407     } catch (...) {
87408       {
87409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87410       };
87411     }
87412   }
87413
87414   jresult = (void *)result;
87415   return jresult;
87416 }
87417
87418
87419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
87420   void * jresult ;
87421   Dali::BaseHandle arg1 ;
87422   Dali::BaseHandle *argp1 ;
87423   Dali::Toolkit::VideoView result;
87424
87425   argp1 = (Dali::BaseHandle *)jarg1;
87426   if (!argp1) {
87427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87428     return 0;
87429   }
87430   arg1 = *argp1;
87431   {
87432     try {
87433       result = Dali::Toolkit::VideoView::DownCast(arg1);
87434     } catch (std::out_of_range& e) {
87435       {
87436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87437       };
87438     } catch (std::exception& e) {
87439       {
87440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87441       };
87442     } catch (Dali::DaliException e) {
87443       {
87444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87445       };
87446     } catch (...) {
87447       {
87448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87449       };
87450     }
87451   }
87452
87453   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87454   return jresult;
87455 }
87456
87457
87458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
87459   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87460
87461   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87462   {
87463     try {
87464       (arg1)->Play();
87465     } catch (std::out_of_range& e) {
87466       {
87467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87468       };
87469     } catch (std::exception& e) {
87470       {
87471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87472       };
87473     } catch (Dali::DaliException e) {
87474       {
87475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87476       };
87477     } catch (...) {
87478       {
87479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87480       };
87481     }
87482   }
87483
87484 }
87485
87486
87487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
87488   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87489
87490   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87491   {
87492     try {
87493       (arg1)->Pause();
87494     } catch (std::out_of_range& e) {
87495       {
87496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87497       };
87498     } catch (std::exception& e) {
87499       {
87500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87501       };
87502     } catch (Dali::DaliException e) {
87503       {
87504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87505       };
87506     } catch (...) {
87507       {
87508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87509       };
87510     }
87511   }
87512
87513 }
87514
87515
87516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
87517   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87518
87519   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87520   {
87521     try {
87522       (arg1)->Stop();
87523     } catch (std::out_of_range& e) {
87524       {
87525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87526       };
87527     } catch (std::exception& e) {
87528       {
87529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87530       };
87531     } catch (Dali::DaliException e) {
87532       {
87533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87534       };
87535     } catch (...) {
87536       {
87537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87538       };
87539     }
87540   }
87541
87542 }
87543
87544
87545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
87546   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87547   int arg2 ;
87548
87549   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87550   arg2 = (int)jarg2;
87551   {
87552     try {
87553       (arg1)->Forward(arg2);
87554     } catch (std::out_of_range& e) {
87555       {
87556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87557       };
87558     } catch (std::exception& e) {
87559       {
87560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87561       };
87562     } catch (Dali::DaliException e) {
87563       {
87564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87565       };
87566     } catch (...) {
87567       {
87568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87569       };
87570     }
87571   }
87572
87573 }
87574
87575
87576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
87577   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87578   int arg2 ;
87579
87580   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87581   arg2 = (int)jarg2;
87582   {
87583     try {
87584       (arg1)->Backward(arg2);
87585     } catch (std::out_of_range& e) {
87586       {
87587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87588       };
87589     } catch (std::exception& e) {
87590       {
87591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87592       };
87593     } catch (Dali::DaliException e) {
87594       {
87595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87596       };
87597     } catch (...) {
87598       {
87599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87600       };
87601     }
87602   }
87603
87604 }
87605
87606
87607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
87608   void * jresult ;
87609   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87610   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
87611
87612   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87613   {
87614     try {
87615       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
87616     } catch (std::out_of_range& e) {
87617       {
87618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87619       };
87620     } catch (std::exception& e) {
87621       {
87622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87623       };
87624     } catch (Dali::DaliException e) {
87625       {
87626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87627       };
87628     } catch (...) {
87629       {
87630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87631       };
87632     }
87633   }
87634
87635   jresult = (void *)result;
87636   return jresult;
87637 }
87638
87639
87640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
87641   int jresult ;
87642   int result;
87643
87644   result = (int)Dali::Toolkit::Popup::Property::TITLE;
87645   jresult = (int)result;
87646   return jresult;
87647 }
87648
87649
87650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
87651   int jresult ;
87652   int result;
87653
87654   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
87655   jresult = (int)result;
87656   return jresult;
87657 }
87658
87659
87660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
87661   int jresult ;
87662   int result;
87663
87664   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
87665   jresult = (int)result;
87666   return jresult;
87667 }
87668
87669
87670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
87671   int jresult ;
87672   int result;
87673
87674   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
87675   jresult = (int)result;
87676   return jresult;
87677 }
87678
87679
87680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
87681   int jresult ;
87682   int result;
87683
87684   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
87685   jresult = (int)result;
87686   return jresult;
87687 }
87688
87689
87690 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
87691   int jresult ;
87692   int result;
87693
87694   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
87695   jresult = (int)result;
87696   return jresult;
87697 }
87698
87699
87700 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
87701   int jresult ;
87702   int result;
87703
87704   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
87705   jresult = (int)result;
87706   return jresult;
87707 }
87708
87709
87710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
87711   int jresult ;
87712   int result;
87713
87714   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
87715   jresult = (int)result;
87716   return jresult;
87717 }
87718
87719
87720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
87721   int jresult ;
87722   int result;
87723
87724   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
87725   jresult = (int)result;
87726   return jresult;
87727 }
87728
87729
87730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
87731   int jresult ;
87732   int result;
87733
87734   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
87735   jresult = (int)result;
87736   return jresult;
87737 }
87738
87739
87740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
87741   int jresult ;
87742   int result;
87743
87744   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
87745   jresult = (int)result;
87746   return jresult;
87747 }
87748
87749
87750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
87751   int jresult ;
87752   int result;
87753
87754   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
87755   jresult = (int)result;
87756   return jresult;
87757 }
87758
87759
87760 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
87761   int jresult ;
87762   int result;
87763
87764   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
87765   jresult = (int)result;
87766   return jresult;
87767 }
87768
87769
87770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
87771   int jresult ;
87772   int result;
87773
87774   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
87775   jresult = (int)result;
87776   return jresult;
87777 }
87778
87779
87780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
87781   int jresult ;
87782   int result;
87783
87784   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
87785   jresult = (int)result;
87786   return jresult;
87787 }
87788
87789
87790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
87791   int jresult ;
87792   int result;
87793
87794   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
87795   jresult = (int)result;
87796   return jresult;
87797 }
87798
87799
87800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
87801   int jresult ;
87802   int result;
87803
87804   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
87805   jresult = (int)result;
87806   return jresult;
87807 }
87808
87809
87810 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
87811   int jresult ;
87812   int result;
87813
87814   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
87815   jresult = (int)result;
87816   return jresult;
87817 }
87818
87819
87820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
87821   int jresult ;
87822   int result;
87823
87824   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
87825   jresult = (int)result;
87826   return jresult;
87827 }
87828
87829
87830 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
87831   int jresult ;
87832   int result;
87833
87834   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
87835   jresult = (int)result;
87836   return jresult;
87837 }
87838
87839
87840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
87841   int jresult ;
87842   int result;
87843
87844   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
87845   jresult = (int)result;
87846   return jresult;
87847 }
87848
87849
87850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
87851   void * jresult ;
87852   Dali::Toolkit::Popup::Property *result = 0 ;
87853
87854   {
87855     try {
87856       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
87857     } catch (std::out_of_range& e) {
87858       {
87859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87860       };
87861     } catch (std::exception& e) {
87862       {
87863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87864       };
87865     } catch (Dali::DaliException e) {
87866       {
87867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87868       };
87869     } catch (...) {
87870       {
87871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87872       };
87873     }
87874   }
87875
87876   jresult = (void *)result;
87877   return jresult;
87878 }
87879
87880
87881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
87882   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
87883
87884   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
87885   {
87886     try {
87887       delete arg1;
87888     } catch (std::out_of_range& e) {
87889       {
87890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87891       };
87892     } catch (std::exception& e) {
87893       {
87894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87895       };
87896     } catch (Dali::DaliException e) {
87897       {
87898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87899       };
87900     } catch (...) {
87901       {
87902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87903       };
87904     }
87905   }
87906
87907 }
87908
87909
87910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
87911   void * jresult ;
87912   Dali::Toolkit::Popup *result = 0 ;
87913
87914   {
87915     try {
87916       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
87917     } catch (std::out_of_range& e) {
87918       {
87919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87920       };
87921     } catch (std::exception& e) {
87922       {
87923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87924       };
87925     } catch (Dali::DaliException e) {
87926       {
87927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87928       };
87929     } catch (...) {
87930       {
87931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87932       };
87933     }
87934   }
87935
87936   jresult = (void *)result;
87937   return jresult;
87938 }
87939
87940
87941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
87942   void * jresult ;
87943   Dali::Toolkit::Popup result;
87944
87945   {
87946     try {
87947       result = Dali::Toolkit::Popup::New();
87948     } catch (std::out_of_range& e) {
87949       {
87950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87951       };
87952     } catch (std::exception& e) {
87953       {
87954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87955       };
87956     } catch (Dali::DaliException e) {
87957       {
87958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87959       };
87960     } catch (...) {
87961       {
87962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87963       };
87964     }
87965   }
87966
87967   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
87968   return jresult;
87969 }
87970
87971
87972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
87973   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87974
87975   arg1 = (Dali::Toolkit::Popup *)jarg1;
87976   {
87977     try {
87978       delete arg1;
87979     } catch (std::out_of_range& e) {
87980       {
87981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87982       };
87983     } catch (std::exception& e) {
87984       {
87985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87986       };
87987     } catch (Dali::DaliException e) {
87988       {
87989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87990       };
87991     } catch (...) {
87992       {
87993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87994       };
87995     }
87996   }
87997
87998 }
87999
88000
88001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
88002   void * jresult ;
88003   Dali::Toolkit::Popup *arg1 = 0 ;
88004   Dali::Toolkit::Popup *result = 0 ;
88005
88006   arg1 = (Dali::Toolkit::Popup *)jarg1;
88007   if (!arg1) {
88008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
88009     return 0;
88010   }
88011   {
88012     try {
88013       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
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_Assign(void * jarg1, void * jarg2) {
88039   void * jresult ;
88040   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88041   Dali::Toolkit::Popup *arg2 = 0 ;
88042   Dali::Toolkit::Popup *result = 0 ;
88043
88044   arg1 = (Dali::Toolkit::Popup *)jarg1;
88045   arg2 = (Dali::Toolkit::Popup *)jarg2;
88046   if (!arg2) {
88047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
88048     return 0;
88049   }
88050   {
88051     try {
88052       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
88053     } catch (std::out_of_range& e) {
88054       {
88055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88056       };
88057     } catch (std::exception& e) {
88058       {
88059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88060       };
88061     } catch (Dali::DaliException e) {
88062       {
88063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88064       };
88065     } catch (...) {
88066       {
88067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88068       };
88069     }
88070   }
88071
88072   jresult = (void *)result;
88073   return jresult;
88074 }
88075
88076
88077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
88078   void * jresult ;
88079   Dali::BaseHandle arg1 ;
88080   Dali::BaseHandle *argp1 ;
88081   Dali::Toolkit::Popup result;
88082
88083   argp1 = (Dali::BaseHandle *)jarg1;
88084   if (!argp1) {
88085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88086     return 0;
88087   }
88088   arg1 = *argp1;
88089   {
88090     try {
88091       result = Dali::Toolkit::Popup::DownCast(arg1);
88092     } catch (std::out_of_range& e) {
88093       {
88094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88095       };
88096     } catch (std::exception& e) {
88097       {
88098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88099       };
88100     } catch (Dali::DaliException e) {
88101       {
88102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88103       };
88104     } catch (...) {
88105       {
88106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88107       };
88108     }
88109   }
88110
88111   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
88112   return jresult;
88113 }
88114
88115
88116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
88117   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88118   Dali::Actor arg2 ;
88119   Dali::Actor *argp2 ;
88120
88121   arg1 = (Dali::Toolkit::Popup *)jarg1;
88122   argp2 = (Dali::Actor *)jarg2;
88123   if (!argp2) {
88124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88125     return ;
88126   }
88127   arg2 = *argp2;
88128   {
88129     try {
88130       (arg1)->SetTitle(arg2);
88131     } catch (std::out_of_range& e) {
88132       {
88133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88134       };
88135     } catch (std::exception& e) {
88136       {
88137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88138       };
88139     } catch (Dali::DaliException e) {
88140       {
88141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88142       };
88143     } catch (...) {
88144       {
88145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88146       };
88147     }
88148   }
88149
88150 }
88151
88152
88153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
88154   void * jresult ;
88155   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88156   Dali::Actor result;
88157
88158   arg1 = (Dali::Toolkit::Popup *)jarg1;
88159   {
88160     try {
88161       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
88162     } catch (std::out_of_range& e) {
88163       {
88164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88165       };
88166     } catch (std::exception& e) {
88167       {
88168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88169       };
88170     } catch (Dali::DaliException e) {
88171       {
88172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88173       };
88174     } catch (...) {
88175       {
88176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88177       };
88178     }
88179   }
88180
88181   jresult = new Dali::Actor((const Dali::Actor &)result);
88182   return jresult;
88183 }
88184
88185
88186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
88187   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88188   Dali::Actor arg2 ;
88189   Dali::Actor *argp2 ;
88190
88191   arg1 = (Dali::Toolkit::Popup *)jarg1;
88192   argp2 = (Dali::Actor *)jarg2;
88193   if (!argp2) {
88194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88195     return ;
88196   }
88197   arg2 = *argp2;
88198   {
88199     try {
88200       (arg1)->SetContent(arg2);
88201     } catch (std::out_of_range& e) {
88202       {
88203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88204       };
88205     } catch (std::exception& e) {
88206       {
88207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88208       };
88209     } catch (Dali::DaliException e) {
88210       {
88211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88212       };
88213     } catch (...) {
88214       {
88215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88216       };
88217     }
88218   }
88219
88220 }
88221
88222
88223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
88224   void * jresult ;
88225   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88226   Dali::Actor result;
88227
88228   arg1 = (Dali::Toolkit::Popup *)jarg1;
88229   {
88230     try {
88231       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
88232     } catch (std::out_of_range& e) {
88233       {
88234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88235       };
88236     } catch (std::exception& e) {
88237       {
88238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88239       };
88240     } catch (Dali::DaliException e) {
88241       {
88242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88243       };
88244     } catch (...) {
88245       {
88246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88247       };
88248     }
88249   }
88250
88251   jresult = new Dali::Actor((const Dali::Actor &)result);
88252   return jresult;
88253 }
88254
88255
88256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
88257   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88258   Dali::Actor arg2 ;
88259   Dali::Actor *argp2 ;
88260
88261   arg1 = (Dali::Toolkit::Popup *)jarg1;
88262   argp2 = (Dali::Actor *)jarg2;
88263   if (!argp2) {
88264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88265     return ;
88266   }
88267   arg2 = *argp2;
88268   {
88269     try {
88270       (arg1)->SetFooter(arg2);
88271     } catch (std::out_of_range& e) {
88272       {
88273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88274       };
88275     } catch (std::exception& e) {
88276       {
88277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88278       };
88279     } catch (Dali::DaliException e) {
88280       {
88281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88282       };
88283     } catch (...) {
88284       {
88285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88286       };
88287     }
88288   }
88289
88290 }
88291
88292
88293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
88294   void * jresult ;
88295   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88296   Dali::Actor result;
88297
88298   arg1 = (Dali::Toolkit::Popup *)jarg1;
88299   {
88300     try {
88301       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
88302     } catch (std::out_of_range& e) {
88303       {
88304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88305       };
88306     } catch (std::exception& e) {
88307       {
88308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88309       };
88310     } catch (Dali::DaliException e) {
88311       {
88312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88313       };
88314     } catch (...) {
88315       {
88316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88317       };
88318     }
88319   }
88320
88321   jresult = new Dali::Actor((const Dali::Actor &)result);
88322   return jresult;
88323 }
88324
88325
88326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
88327   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88328   Dali::Toolkit::Popup::DisplayState arg2 ;
88329
88330   arg1 = (Dali::Toolkit::Popup *)jarg1;
88331   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
88332   {
88333     try {
88334       (arg1)->SetDisplayState(arg2);
88335     } catch (std::out_of_range& e) {
88336       {
88337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88338       };
88339     } catch (std::exception& e) {
88340       {
88341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88342       };
88343     } catch (Dali::DaliException e) {
88344       {
88345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88346       };
88347     } catch (...) {
88348       {
88349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88350       };
88351     }
88352   }
88353
88354 }
88355
88356
88357 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
88358   int jresult ;
88359   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88360   Dali::Toolkit::Popup::DisplayState result;
88361
88362   arg1 = (Dali::Toolkit::Popup *)jarg1;
88363   {
88364     try {
88365       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
88366     } catch (std::out_of_range& e) {
88367       {
88368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88369       };
88370     } catch (std::exception& e) {
88371       {
88372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88373       };
88374     } catch (Dali::DaliException e) {
88375       {
88376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88377       };
88378     } catch (...) {
88379       {
88380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88381       };
88382     }
88383   }
88384
88385   jresult = (int)result;
88386   return jresult;
88387 }
88388
88389
88390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
88391   void * jresult ;
88392   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88393   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
88394
88395   arg1 = (Dali::Toolkit::Popup *)jarg1;
88396   {
88397     try {
88398       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
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 = (void *)result;
88419   return jresult;
88420 }
88421
88422
88423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
88424   void * jresult ;
88425   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88426   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88427
88428   arg1 = (Dali::Toolkit::Popup *)jarg1;
88429   {
88430     try {
88431       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
88432     } catch (std::out_of_range& e) {
88433       {
88434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88435       };
88436     } catch (std::exception& e) {
88437       {
88438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88439       };
88440     } catch (Dali::DaliException e) {
88441       {
88442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88443       };
88444     } catch (...) {
88445       {
88446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88447       };
88448     }
88449   }
88450
88451   jresult = (void *)result;
88452   return jresult;
88453 }
88454
88455
88456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
88457   void * jresult ;
88458   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88459   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88460
88461   arg1 = (Dali::Toolkit::Popup *)jarg1;
88462   {
88463     try {
88464       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
88465     } catch (std::out_of_range& e) {
88466       {
88467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88468       };
88469     } catch (std::exception& e) {
88470       {
88471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88472       };
88473     } catch (Dali::DaliException e) {
88474       {
88475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88476       };
88477     } catch (...) {
88478       {
88479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88480       };
88481     }
88482   }
88483
88484   jresult = (void *)result;
88485   return jresult;
88486 }
88487
88488
88489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
88490   void * jresult ;
88491   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88492   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88493
88494   arg1 = (Dali::Toolkit::Popup *)jarg1;
88495   {
88496     try {
88497       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
88498     } catch (std::out_of_range& e) {
88499       {
88500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88501       };
88502     } catch (std::exception& e) {
88503       {
88504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88505       };
88506     } catch (Dali::DaliException e) {
88507       {
88508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88509       };
88510     } catch (...) {
88511       {
88512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88513       };
88514     }
88515   }
88516
88517   jresult = (void *)result;
88518   return jresult;
88519 }
88520
88521
88522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
88523   void * jresult ;
88524   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88525   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88526
88527   arg1 = (Dali::Toolkit::Popup *)jarg1;
88528   {
88529     try {
88530       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
88531     } catch (std::out_of_range& e) {
88532       {
88533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88534       };
88535     } catch (std::exception& e) {
88536       {
88537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88538       };
88539     } catch (Dali::DaliException e) {
88540       {
88541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88542       };
88543     } catch (...) {
88544       {
88545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88546       };
88547     }
88548   }
88549
88550   jresult = (void *)result;
88551   return jresult;
88552 }
88553
88554
88555 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
88556   int jresult ;
88557   int result;
88558
88559   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
88560   jresult = (int)result;
88561   return jresult;
88562 }
88563
88564
88565 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
88566   int jresult ;
88567   int result;
88568
88569   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
88570   jresult = (int)result;
88571   return jresult;
88572 }
88573
88574
88575 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
88576   int jresult ;
88577   int result;
88578
88579   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
88580   jresult = (int)result;
88581   return jresult;
88582 }
88583
88584
88585 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
88586   int jresult ;
88587   int result;
88588
88589   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
88590   jresult = (int)result;
88591   return jresult;
88592 }
88593
88594
88595 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
88596   int jresult ;
88597   int result;
88598
88599   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
88600   jresult = (int)result;
88601   return jresult;
88602 }
88603
88604
88605 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
88606   int jresult ;
88607   int result;
88608
88609   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
88610   jresult = (int)result;
88611   return jresult;
88612 }
88613
88614
88615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
88616   int jresult ;
88617   int result;
88618
88619   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
88620   jresult = (int)result;
88621   return jresult;
88622 }
88623
88624
88625 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
88626   int jresult ;
88627   int result;
88628
88629   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
88630   jresult = (int)result;
88631   return jresult;
88632 }
88633
88634
88635 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
88636   int jresult ;
88637   int result;
88638
88639   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
88640   jresult = (int)result;
88641   return jresult;
88642 }
88643
88644
88645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
88646   void * jresult ;
88647   Dali::Toolkit::ProgressBar::Property *result = 0 ;
88648
88649   {
88650     try {
88651       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
88652     } catch (std::out_of_range& e) {
88653       {
88654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88655       };
88656     } catch (std::exception& e) {
88657       {
88658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88659       };
88660     } catch (Dali::DaliException e) {
88661       {
88662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88663       };
88664     } catch (...) {
88665       {
88666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88667       };
88668     }
88669   }
88670
88671   jresult = (void *)result;
88672   return jresult;
88673 }
88674
88675
88676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
88677   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
88678
88679   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
88680   {
88681     try {
88682       delete arg1;
88683     } catch (std::out_of_range& e) {
88684       {
88685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88686       };
88687     } catch (std::exception& e) {
88688       {
88689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88690       };
88691     } catch (Dali::DaliException e) {
88692       {
88693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88694       };
88695     } catch (...) {
88696       {
88697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88698       };
88699     }
88700   }
88701
88702 }
88703
88704
88705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
88706   void * jresult ;
88707   Dali::Toolkit::ProgressBar result;
88708
88709   {
88710     try {
88711       result = Dali::Toolkit::ProgressBar::New();
88712     } catch (std::out_of_range& e) {
88713       {
88714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88715       };
88716     } catch (std::exception& e) {
88717       {
88718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88719       };
88720     } catch (Dali::DaliException e) {
88721       {
88722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88723       };
88724     } catch (...) {
88725       {
88726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88727       };
88728     }
88729   }
88730
88731   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
88732   return jresult;
88733 }
88734
88735
88736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
88737   void * jresult ;
88738   Dali::Toolkit::ProgressBar *result = 0 ;
88739
88740   {
88741     try {
88742       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
88743     } catch (std::out_of_range& e) {
88744       {
88745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88746       };
88747     } catch (std::exception& e) {
88748       {
88749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88750       };
88751     } catch (Dali::DaliException e) {
88752       {
88753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88754       };
88755     } catch (...) {
88756       {
88757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88758       };
88759     }
88760   }
88761
88762   jresult = (void *)result;
88763   return jresult;
88764 }
88765
88766
88767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
88768   void * jresult ;
88769   Dali::Toolkit::ProgressBar *arg1 = 0 ;
88770   Dali::Toolkit::ProgressBar *result = 0 ;
88771
88772   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88773   if (!arg1) {
88774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
88775     return 0;
88776   }
88777   {
88778     try {
88779       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
88780     } catch (std::out_of_range& e) {
88781       {
88782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88783       };
88784     } catch (std::exception& e) {
88785       {
88786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88787       };
88788     } catch (Dali::DaliException e) {
88789       {
88790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88791       };
88792     } catch (...) {
88793       {
88794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88795       };
88796     }
88797   }
88798
88799   jresult = (void *)result;
88800   return jresult;
88801 }
88802
88803
88804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
88805   void * jresult ;
88806   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
88807   Dali::Toolkit::ProgressBar *arg2 = 0 ;
88808   Dali::Toolkit::ProgressBar *result = 0 ;
88809
88810   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88811   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
88812   if (!arg2) {
88813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
88814     return 0;
88815   }
88816   {
88817     try {
88818       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
88819     } catch (std::out_of_range& e) {
88820       {
88821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88822       };
88823     } catch (std::exception& e) {
88824       {
88825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88826       };
88827     } catch (Dali::DaliException e) {
88828       {
88829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88830       };
88831     } catch (...) {
88832       {
88833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88834       };
88835     }
88836   }
88837
88838   jresult = (void *)result;
88839   return jresult;
88840 }
88841
88842
88843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
88844   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
88845
88846   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88847   {
88848     try {
88849       delete arg1;
88850     } catch (std::out_of_range& e) {
88851       {
88852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88853       };
88854     } catch (std::exception& e) {
88855       {
88856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88857       };
88858     } catch (Dali::DaliException e) {
88859       {
88860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88861       };
88862     } catch (...) {
88863       {
88864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88865       };
88866     }
88867   }
88868
88869 }
88870
88871
88872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
88873   void * jresult ;
88874   Dali::BaseHandle arg1 ;
88875   Dali::BaseHandle *argp1 ;
88876   Dali::Toolkit::ProgressBar result;
88877
88878   argp1 = (Dali::BaseHandle *)jarg1;
88879   if (!argp1) {
88880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88881     return 0;
88882   }
88883   arg1 = *argp1;
88884   {
88885     try {
88886       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
88887     } catch (std::out_of_range& e) {
88888       {
88889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88890       };
88891     } catch (std::exception& e) {
88892       {
88893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88894       };
88895     } catch (Dali::DaliException e) {
88896       {
88897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88898       };
88899     } catch (...) {
88900       {
88901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88902       };
88903     }
88904   }
88905
88906   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
88907   return jresult;
88908 }
88909
88910
88911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
88912   void * jresult ;
88913   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
88914   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
88915
88916   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88917   {
88918     try {
88919       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
88920     } catch (std::out_of_range& e) {
88921       {
88922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88923       };
88924     } catch (std::exception& e) {
88925       {
88926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88927       };
88928     } catch (Dali::DaliException e) {
88929       {
88930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88931       };
88932     } catch (...) {
88933       {
88934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88935       };
88936     }
88937   }
88938
88939   jresult = (void *)result;
88940   return jresult;
88941 }
88942
88943
88944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
88945   void * jresult ;
88946   Dali::Toolkit::GaussianBlurView *result = 0 ;
88947
88948   {
88949     try {
88950       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
88951     } catch (std::out_of_range& e) {
88952       {
88953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88954       };
88955     } catch (std::exception& e) {
88956       {
88957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88958       };
88959     } catch (Dali::DaliException e) {
88960       {
88961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88962       };
88963     } catch (...) {
88964       {
88965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88966       };
88967     }
88968   }
88969
88970   jresult = (void *)result;
88971   return jresult;
88972 }
88973
88974
88975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
88976   void * jresult ;
88977   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
88978   Dali::Toolkit::GaussianBlurView *result = 0 ;
88979
88980   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88981   if (!arg1) {
88982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
88983     return 0;
88984   }
88985   {
88986     try {
88987       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
88988     } catch (std::out_of_range& e) {
88989       {
88990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88991       };
88992     } catch (std::exception& e) {
88993       {
88994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88995       };
88996     } catch (Dali::DaliException e) {
88997       {
88998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88999       };
89000     } catch (...) {
89001       {
89002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89003       };
89004     }
89005   }
89006
89007   jresult = (void *)result;
89008   return jresult;
89009 }
89010
89011
89012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
89013   void * jresult ;
89014   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89015   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
89016   Dali::Toolkit::GaussianBlurView *result = 0 ;
89017
89018   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89019   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
89020   if (!arg2) {
89021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
89022     return 0;
89023   }
89024   {
89025     try {
89026       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
89027     } catch (std::out_of_range& e) {
89028       {
89029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89030       };
89031     } catch (std::exception& e) {
89032       {
89033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89034       };
89035     } catch (Dali::DaliException e) {
89036       {
89037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89038       };
89039     } catch (...) {
89040       {
89041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89042       };
89043     }
89044   }
89045
89046   jresult = (void *)result;
89047   return jresult;
89048 }
89049
89050
89051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
89052   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89053
89054   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89055   {
89056     try {
89057       delete arg1;
89058     } catch (std::out_of_range& e) {
89059       {
89060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89061       };
89062     } catch (std::exception& e) {
89063       {
89064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89065       };
89066     } catch (Dali::DaliException e) {
89067       {
89068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89069       };
89070     } catch (...) {
89071       {
89072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89073       };
89074     }
89075   }
89076
89077 }
89078
89079
89080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
89081   void * jresult ;
89082   Dali::BaseHandle arg1 ;
89083   Dali::BaseHandle *argp1 ;
89084   Dali::Toolkit::GaussianBlurView result;
89085
89086   argp1 = (Dali::BaseHandle *)jarg1;
89087   if (!argp1) {
89088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89089     return 0;
89090   }
89091   arg1 = *argp1;
89092   {
89093     try {
89094       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
89095     } catch (std::out_of_range& e) {
89096       {
89097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89098       };
89099     } catch (std::exception& e) {
89100       {
89101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89102       };
89103     } catch (Dali::DaliException e) {
89104       {
89105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89106       };
89107     } catch (...) {
89108       {
89109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89110       };
89111     }
89112   }
89113
89114   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89115   return jresult;
89116 }
89117
89118
89119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
89120   void * jresult ;
89121   Dali::Toolkit::GaussianBlurView result;
89122
89123   {
89124     try {
89125       result = Dali::Toolkit::GaussianBlurView::New();
89126     } catch (std::out_of_range& e) {
89127       {
89128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89129       };
89130     } catch (std::exception& e) {
89131       {
89132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89133       };
89134     } catch (Dali::DaliException e) {
89135       {
89136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89137       };
89138     } catch (...) {
89139       {
89140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89141       };
89142     }
89143   }
89144
89145   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89146   return jresult;
89147 }
89148
89149
89150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
89151   void * jresult ;
89152   unsigned int arg1 ;
89153   float arg2 ;
89154   Dali::Pixel::Format arg3 ;
89155   float arg4 ;
89156   float arg5 ;
89157   bool arg6 ;
89158   Dali::Toolkit::GaussianBlurView result;
89159
89160   arg1 = (unsigned int)jarg1;
89161   arg2 = (float)jarg2;
89162   arg3 = (Dali::Pixel::Format)jarg3;
89163   arg4 = (float)jarg4;
89164   arg5 = (float)jarg5;
89165   arg6 = jarg6 ? true : false;
89166   {
89167     try {
89168       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
89169     } catch (std::out_of_range& e) {
89170       {
89171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89172       };
89173     } catch (std::exception& e) {
89174       {
89175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89176       };
89177     } catch (Dali::DaliException e) {
89178       {
89179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89180       };
89181     } catch (...) {
89182       {
89183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89184       };
89185     }
89186   }
89187
89188   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89189   return jresult;
89190 }
89191
89192
89193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
89194   void * jresult ;
89195   unsigned int arg1 ;
89196   float arg2 ;
89197   Dali::Pixel::Format arg3 ;
89198   float arg4 ;
89199   float arg5 ;
89200   Dali::Toolkit::GaussianBlurView result;
89201
89202   arg1 = (unsigned int)jarg1;
89203   arg2 = (float)jarg2;
89204   arg3 = (Dali::Pixel::Format)jarg3;
89205   arg4 = (float)jarg4;
89206   arg5 = (float)jarg5;
89207   {
89208     try {
89209       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
89210     } catch (std::out_of_range& e) {
89211       {
89212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89213       };
89214     } catch (std::exception& e) {
89215       {
89216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89217       };
89218     } catch (Dali::DaliException e) {
89219       {
89220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89221       };
89222     } catch (...) {
89223       {
89224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89225       };
89226     }
89227   }
89228
89229   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89230   return jresult;
89231 }
89232
89233
89234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
89235   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89236   Dali::Actor arg2 ;
89237   Dali::Actor *argp2 ;
89238
89239   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89240   argp2 = (Dali::Actor *)jarg2;
89241   if (!argp2) {
89242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89243     return ;
89244   }
89245   arg2 = *argp2;
89246   {
89247     try {
89248       (arg1)->Add(arg2);
89249     } catch (std::out_of_range& e) {
89250       {
89251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89252       };
89253     } catch (std::exception& e) {
89254       {
89255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89256       };
89257     } catch (Dali::DaliException e) {
89258       {
89259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89260       };
89261     } catch (...) {
89262       {
89263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89264       };
89265     }
89266   }
89267
89268 }
89269
89270
89271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
89272   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89273   Dali::Actor arg2 ;
89274   Dali::Actor *argp2 ;
89275
89276   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89277   argp2 = (Dali::Actor *)jarg2;
89278   if (!argp2) {
89279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89280     return ;
89281   }
89282   arg2 = *argp2;
89283   {
89284     try {
89285       (arg1)->Remove(arg2);
89286     } catch (std::out_of_range& e) {
89287       {
89288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89289       };
89290     } catch (std::exception& e) {
89291       {
89292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89293       };
89294     } catch (Dali::DaliException e) {
89295       {
89296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89297       };
89298     } catch (...) {
89299       {
89300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89301       };
89302     }
89303   }
89304
89305 }
89306
89307
89308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
89309   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89310
89311   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89312   {
89313     try {
89314       (arg1)->Activate();
89315     } catch (std::out_of_range& e) {
89316       {
89317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89318       };
89319     } catch (std::exception& e) {
89320       {
89321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89322       };
89323     } catch (Dali::DaliException e) {
89324       {
89325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89326       };
89327     } catch (...) {
89328       {
89329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89330       };
89331     }
89332   }
89333
89334 }
89335
89336
89337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
89338   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89339
89340   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89341   {
89342     try {
89343       (arg1)->ActivateOnce();
89344     } catch (std::out_of_range& e) {
89345       {
89346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89347       };
89348     } catch (std::exception& e) {
89349       {
89350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89351       };
89352     } catch (Dali::DaliException e) {
89353       {
89354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89355       };
89356     } catch (...) {
89357       {
89358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89359       };
89360     }
89361   }
89362
89363 }
89364
89365
89366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
89367   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89368
89369   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89370   {
89371     try {
89372       (arg1)->Deactivate();
89373     } catch (std::out_of_range& e) {
89374       {
89375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89376       };
89377     } catch (std::exception& e) {
89378       {
89379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89380       };
89381     } catch (Dali::DaliException e) {
89382       {
89383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89384       };
89385     } catch (...) {
89386       {
89387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89388       };
89389     }
89390   }
89391
89392 }
89393
89394
89395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
89396   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89397   Dali::Image arg2 ;
89398   Dali::FrameBufferImage arg3 ;
89399   Dali::Image *argp2 ;
89400   Dali::FrameBufferImage *argp3 ;
89401
89402   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89403   argp2 = (Dali::Image *)jarg2;
89404   if (!argp2) {
89405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
89406     return ;
89407   }
89408   arg2 = *argp2;
89409   argp3 = (Dali::FrameBufferImage *)jarg3;
89410   if (!argp3) {
89411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
89412     return ;
89413   }
89414   arg3 = *argp3;
89415   {
89416     try {
89417       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
89418     } catch (std::out_of_range& e) {
89419       {
89420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89421       };
89422     } catch (std::exception& e) {
89423       {
89424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89425       };
89426     } catch (Dali::DaliException e) {
89427       {
89428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89429       };
89430     } catch (...) {
89431       {
89432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89433       };
89434     }
89435   }
89436
89437 }
89438
89439
89440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
89441   int jresult ;
89442   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89443   Dali::Property::Index result;
89444
89445   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89446   {
89447     try {
89448       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
89449     } catch (std::out_of_range& e) {
89450       {
89451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89452       };
89453     } catch (std::exception& e) {
89454       {
89455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89456       };
89457     } catch (Dali::DaliException e) {
89458       {
89459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89460       };
89461     } catch (...) {
89462       {
89463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89464       };
89465     }
89466   }
89467
89468   jresult = result;
89469   return jresult;
89470 }
89471
89472
89473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
89474   void * jresult ;
89475   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89476   Dali::FrameBufferImage result;
89477
89478   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89479   {
89480     try {
89481       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
89482     } catch (std::out_of_range& e) {
89483       {
89484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89485       };
89486     } catch (std::exception& e) {
89487       {
89488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89489       };
89490     } catch (Dali::DaliException e) {
89491       {
89492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89493       };
89494     } catch (...) {
89495       {
89496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89497       };
89498     }
89499   }
89500
89501   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
89502   return jresult;
89503 }
89504
89505
89506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
89507   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89508   Dali::Vector4 *arg2 = 0 ;
89509
89510   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89511   arg2 = (Dali::Vector4 *)jarg2;
89512   if (!arg2) {
89513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
89514     return ;
89515   }
89516   {
89517     try {
89518       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
89519     } catch (std::out_of_range& e) {
89520       {
89521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89522       };
89523     } catch (std::exception& e) {
89524       {
89525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89526       };
89527     } catch (Dali::DaliException e) {
89528       {
89529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89530       };
89531     } catch (...) {
89532       {
89533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89534       };
89535     }
89536   }
89537
89538 }
89539
89540
89541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
89542   void * jresult ;
89543   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89544   Dali::Vector4 result;
89545
89546   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89547   {
89548     try {
89549       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
89550     } catch (std::out_of_range& e) {
89551       {
89552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89553       };
89554     } catch (std::exception& e) {
89555       {
89556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89557       };
89558     } catch (Dali::DaliException e) {
89559       {
89560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89561       };
89562     } catch (...) {
89563       {
89564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89565       };
89566     }
89567   }
89568
89569   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
89570   return jresult;
89571 }
89572
89573
89574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
89575   void * jresult ;
89576   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89577   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
89578
89579   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89580   {
89581     try {
89582       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
89583     } catch (std::out_of_range& e) {
89584       {
89585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89586       };
89587     } catch (std::exception& e) {
89588       {
89589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89590       };
89591     } catch (Dali::DaliException e) {
89592       {
89593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89594       };
89595     } catch (...) {
89596       {
89597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89598       };
89599     }
89600   }
89601
89602   jresult = (void *)result;
89603   return jresult;
89604 }
89605
89606
89607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
89608   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89609
89610   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89611   {
89612     try {
89613       delete arg1;
89614     } catch (std::out_of_range& e) {
89615       {
89616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89617       };
89618     } catch (std::exception& e) {
89619       {
89620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89621       };
89622     } catch (Dali::DaliException e) {
89623       {
89624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89625       };
89626     } catch (...) {
89627       {
89628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89629       };
89630     }
89631   }
89632
89633 }
89634
89635
89636 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
89637   unsigned int jresult ;
89638   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89639   unsigned int result;
89640
89641   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89642   {
89643     try {
89644       result = (unsigned int)(arg1)->GetNumberOfPages();
89645     } catch (std::out_of_range& e) {
89646       {
89647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89648       };
89649     } catch (std::exception& e) {
89650       {
89651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89652       };
89653     } catch (Dali::DaliException e) {
89654       {
89655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89656       };
89657     } catch (...) {
89658       {
89659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89660       };
89661     }
89662   }
89663
89664   jresult = result;
89665   return jresult;
89666 }
89667
89668
89669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
89670   void * jresult ;
89671   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89672   unsigned int arg2 ;
89673   Dali::Texture result;
89674
89675   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89676   arg2 = (unsigned int)jarg2;
89677   {
89678     try {
89679       result = (arg1)->NewPage(arg2);
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 = new Dali::Texture((const Dali::Texture &)result);
89700   return jresult;
89701 }
89702
89703
89704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
89705   int jresult ;
89706   int result;
89707
89708   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
89709   jresult = (int)result;
89710   return jresult;
89711 }
89712
89713
89714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
89715   int jresult ;
89716   int result;
89717
89718   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
89719   jresult = (int)result;
89720   return jresult;
89721 }
89722
89723
89724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
89725   int jresult ;
89726   int result;
89727
89728   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
89729   jresult = (int)result;
89730   return jresult;
89731 }
89732
89733
89734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
89735   void * jresult ;
89736   Dali::Toolkit::PageTurnView::Property *result = 0 ;
89737
89738   {
89739     try {
89740       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
89741     } catch (std::out_of_range& e) {
89742       {
89743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89744       };
89745     } catch (std::exception& e) {
89746       {
89747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89748       };
89749     } catch (Dali::DaliException e) {
89750       {
89751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89752       };
89753     } catch (...) {
89754       {
89755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89756       };
89757     }
89758   }
89759
89760   jresult = (void *)result;
89761   return jresult;
89762 }
89763
89764
89765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
89766   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
89767
89768   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
89769   {
89770     try {
89771       delete arg1;
89772     } catch (std::out_of_range& e) {
89773       {
89774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89775       };
89776     } catch (std::exception& e) {
89777       {
89778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89779       };
89780     } catch (Dali::DaliException e) {
89781       {
89782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89783       };
89784     } catch (...) {
89785       {
89786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89787       };
89788     }
89789   }
89790
89791 }
89792
89793
89794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
89795   void * jresult ;
89796   Dali::Toolkit::PageTurnView *result = 0 ;
89797
89798   {
89799     try {
89800       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
89801     } catch (std::out_of_range& e) {
89802       {
89803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89804       };
89805     } catch (std::exception& e) {
89806       {
89807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89808       };
89809     } catch (Dali::DaliException e) {
89810       {
89811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89812       };
89813     } catch (...) {
89814       {
89815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89816       };
89817     }
89818   }
89819
89820   jresult = (void *)result;
89821   return jresult;
89822 }
89823
89824
89825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
89826   void * jresult ;
89827   Dali::Toolkit::PageTurnView *arg1 = 0 ;
89828   Dali::Toolkit::PageTurnView *result = 0 ;
89829
89830   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89831   if (!arg1) {
89832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
89833     return 0;
89834   }
89835   {
89836     try {
89837       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
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_PageTurnView_Assign(void * jarg1, void * jarg2) {
89863   void * jresult ;
89864   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89865   Dali::Toolkit::PageTurnView *arg2 = 0 ;
89866   Dali::Toolkit::PageTurnView *result = 0 ;
89867
89868   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89869   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
89870   if (!arg2) {
89871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
89872     return 0;
89873   }
89874   {
89875     try {
89876       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
89877     } catch (std::out_of_range& e) {
89878       {
89879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89880       };
89881     } catch (std::exception& e) {
89882       {
89883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89884       };
89885     } catch (Dali::DaliException e) {
89886       {
89887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89888       };
89889     } catch (...) {
89890       {
89891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89892       };
89893     }
89894   }
89895
89896   jresult = (void *)result;
89897   return jresult;
89898 }
89899
89900
89901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
89902   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89903
89904   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89905   {
89906     try {
89907       delete arg1;
89908     } catch (std::out_of_range& e) {
89909       {
89910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89911       };
89912     } catch (std::exception& e) {
89913       {
89914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89915       };
89916     } catch (Dali::DaliException e) {
89917       {
89918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89919       };
89920     } catch (...) {
89921       {
89922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89923       };
89924     }
89925   }
89926
89927 }
89928
89929
89930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
89931   void * jresult ;
89932   Dali::BaseHandle arg1 ;
89933   Dali::BaseHandle *argp1 ;
89934   Dali::Toolkit::PageTurnView result;
89935
89936   argp1 = (Dali::BaseHandle *)jarg1;
89937   if (!argp1) {
89938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89939     return 0;
89940   }
89941   arg1 = *argp1;
89942   {
89943     try {
89944       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
89945     } catch (std::out_of_range& e) {
89946       {
89947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89948       };
89949     } catch (std::exception& e) {
89950       {
89951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89952       };
89953     } catch (Dali::DaliException e) {
89954       {
89955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89956       };
89957     } catch (...) {
89958       {
89959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89960       };
89961     }
89962   }
89963
89964   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
89965   return jresult;
89966 }
89967
89968
89969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
89970   void * jresult ;
89971   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89972   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
89973
89974   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89975   {
89976     try {
89977       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
89978     } catch (std::out_of_range& e) {
89979       {
89980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89981       };
89982     } catch (std::exception& e) {
89983       {
89984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89985       };
89986     } catch (Dali::DaliException e) {
89987       {
89988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89989       };
89990     } catch (...) {
89991       {
89992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89993       };
89994     }
89995   }
89996
89997   jresult = (void *)result;
89998   return jresult;
89999 }
90000
90001
90002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
90003   void * jresult ;
90004   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90005   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
90006
90007   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90008   {
90009     try {
90010       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
90011     } catch (std::out_of_range& e) {
90012       {
90013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90014       };
90015     } catch (std::exception& e) {
90016       {
90017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90018       };
90019     } catch (Dali::DaliException e) {
90020       {
90021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90022       };
90023     } catch (...) {
90024       {
90025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90026       };
90027     }
90028   }
90029
90030   jresult = (void *)result;
90031   return jresult;
90032 }
90033
90034
90035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
90036   void * jresult ;
90037   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90038   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
90039
90040   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90041   {
90042     try {
90043       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
90044     } catch (std::out_of_range& e) {
90045       {
90046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90047       };
90048     } catch (std::exception& e) {
90049       {
90050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90051       };
90052     } catch (Dali::DaliException e) {
90053       {
90054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90055       };
90056     } catch (...) {
90057       {
90058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90059       };
90060     }
90061   }
90062
90063   jresult = (void *)result;
90064   return jresult;
90065 }
90066
90067
90068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
90069   void * jresult ;
90070   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90071   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
90072
90073   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90074   {
90075     try {
90076       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
90077     } catch (std::out_of_range& e) {
90078       {
90079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90080       };
90081     } catch (std::exception& e) {
90082       {
90083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90084       };
90085     } catch (Dali::DaliException e) {
90086       {
90087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90088       };
90089     } catch (...) {
90090       {
90091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90092       };
90093     }
90094   }
90095
90096   jresult = (void *)result;
90097   return jresult;
90098 }
90099
90100
90101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
90102   void * jresult ;
90103   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90104
90105   {
90106     try {
90107       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
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_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
90133   void * jresult ;
90134   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
90135   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90136
90137   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90138   if (!arg1) {
90139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90140     return 0;
90141   }
90142   {
90143     try {
90144       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
90145     } catch (std::out_of_range& e) {
90146       {
90147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90148       };
90149     } catch (std::exception& e) {
90150       {
90151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90152       };
90153     } catch (Dali::DaliException e) {
90154       {
90155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90156       };
90157     } catch (...) {
90158       {
90159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90160       };
90161     }
90162   }
90163
90164   jresult = (void *)result;
90165   return jresult;
90166 }
90167
90168
90169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
90170   void * jresult ;
90171   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90172   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
90173   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90174
90175   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90176   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
90177   if (!arg2) {
90178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90179     return 0;
90180   }
90181   {
90182     try {
90183       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
90184     } catch (std::out_of_range& e) {
90185       {
90186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90187       };
90188     } catch (std::exception& e) {
90189       {
90190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90191       };
90192     } catch (Dali::DaliException e) {
90193       {
90194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90195       };
90196     } catch (...) {
90197       {
90198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90199       };
90200     }
90201   }
90202
90203   jresult = (void *)result;
90204   return jresult;
90205 }
90206
90207
90208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
90209   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90210
90211   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90212   {
90213     try {
90214       delete arg1;
90215     } catch (std::out_of_range& e) {
90216       {
90217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90218       };
90219     } catch (std::exception& e) {
90220       {
90221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90222       };
90223     } catch (Dali::DaliException e) {
90224       {
90225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90226       };
90227     } catch (...) {
90228       {
90229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90230       };
90231     }
90232   }
90233
90234 }
90235
90236
90237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
90238   void * jresult ;
90239   Dali::Toolkit::PageFactory *arg1 = 0 ;
90240   Dali::Vector2 *arg2 = 0 ;
90241   Dali::Toolkit::PageTurnLandscapeView result;
90242
90243   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90244   if (!arg1) {
90245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90246     return 0;
90247   }
90248   arg2 = (Dali::Vector2 *)jarg2;
90249   if (!arg2) {
90250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90251     return 0;
90252   }
90253   {
90254     try {
90255       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
90256     } catch (std::out_of_range& e) {
90257       {
90258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90259       };
90260     } catch (std::exception& e) {
90261       {
90262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90263       };
90264     } catch (Dali::DaliException e) {
90265       {
90266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90267       };
90268     } catch (...) {
90269       {
90270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90271       };
90272     }
90273   }
90274
90275   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90276   return jresult;
90277 }
90278
90279
90280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
90281   void * jresult ;
90282   Dali::BaseHandle arg1 ;
90283   Dali::BaseHandle *argp1 ;
90284   Dali::Toolkit::PageTurnLandscapeView result;
90285
90286   argp1 = (Dali::BaseHandle *)jarg1;
90287   if (!argp1) {
90288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90289     return 0;
90290   }
90291   arg1 = *argp1;
90292   {
90293     try {
90294       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
90295     } catch (std::out_of_range& e) {
90296       {
90297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90298       };
90299     } catch (std::exception& e) {
90300       {
90301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90302       };
90303     } catch (Dali::DaliException e) {
90304       {
90305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90306       };
90307     } catch (...) {
90308       {
90309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90310       };
90311     }
90312   }
90313
90314   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90315   return jresult;
90316 }
90317
90318
90319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
90320   void * jresult ;
90321   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90322
90323   {
90324     try {
90325       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
90326     } catch (std::out_of_range& e) {
90327       {
90328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90329       };
90330     } catch (std::exception& e) {
90331       {
90332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90333       };
90334     } catch (Dali::DaliException e) {
90335       {
90336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90337       };
90338     } catch (...) {
90339       {
90340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90341       };
90342     }
90343   }
90344
90345   jresult = (void *)result;
90346   return jresult;
90347 }
90348
90349
90350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
90351   void * jresult ;
90352   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
90353   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90354
90355   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90356   if (!arg1) {
90357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90358     return 0;
90359   }
90360   {
90361     try {
90362       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
90363     } catch (std::out_of_range& e) {
90364       {
90365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90366       };
90367     } catch (std::exception& e) {
90368       {
90369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90370       };
90371     } catch (Dali::DaliException e) {
90372       {
90373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90374       };
90375     } catch (...) {
90376       {
90377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90378       };
90379     }
90380   }
90381
90382   jresult = (void *)result;
90383   return jresult;
90384 }
90385
90386
90387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
90388   void * jresult ;
90389   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90390   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
90391   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90392
90393   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90394   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
90395   if (!arg2) {
90396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90397     return 0;
90398   }
90399   {
90400     try {
90401       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
90402     } catch (std::out_of_range& e) {
90403       {
90404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90405       };
90406     } catch (std::exception& e) {
90407       {
90408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90409       };
90410     } catch (Dali::DaliException e) {
90411       {
90412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90413       };
90414     } catch (...) {
90415       {
90416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90417       };
90418     }
90419   }
90420
90421   jresult = (void *)result;
90422   return jresult;
90423 }
90424
90425
90426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
90427   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90428
90429   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90430   {
90431     try {
90432       delete arg1;
90433     } catch (std::out_of_range& e) {
90434       {
90435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90436       };
90437     } catch (std::exception& e) {
90438       {
90439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90440       };
90441     } catch (Dali::DaliException e) {
90442       {
90443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90444       };
90445     } catch (...) {
90446       {
90447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90448       };
90449     }
90450   }
90451
90452 }
90453
90454
90455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
90456   void * jresult ;
90457   Dali::Toolkit::PageFactory *arg1 = 0 ;
90458   Dali::Vector2 *arg2 = 0 ;
90459   Dali::Toolkit::PageTurnPortraitView result;
90460
90461   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90462   if (!arg1) {
90463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90464     return 0;
90465   }
90466   arg2 = (Dali::Vector2 *)jarg2;
90467   if (!arg2) {
90468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90469     return 0;
90470   }
90471   {
90472     try {
90473       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
90474     } catch (std::out_of_range& e) {
90475       {
90476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90477       };
90478     } catch (std::exception& e) {
90479       {
90480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90481       };
90482     } catch (Dali::DaliException e) {
90483       {
90484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90485       };
90486     } catch (...) {
90487       {
90488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90489       };
90490     }
90491   }
90492
90493   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
90494   return jresult;
90495 }
90496
90497
90498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
90499   void * jresult ;
90500   Dali::BaseHandle arg1 ;
90501   Dali::BaseHandle *argp1 ;
90502   Dali::Toolkit::PageTurnPortraitView result;
90503
90504   argp1 = (Dali::BaseHandle *)jarg1;
90505   if (!argp1) {
90506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90507     return 0;
90508   }
90509   arg1 = *argp1;
90510   {
90511     try {
90512       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
90513     } catch (std::out_of_range& e) {
90514       {
90515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90516       };
90517     } catch (std::exception& e) {
90518       {
90519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90520       };
90521     } catch (Dali::DaliException e) {
90522       {
90523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90524       };
90525     } catch (...) {
90526       {
90527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90528       };
90529     }
90530   }
90531
90532   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
90533   return jresult;
90534 }
90535
90536
90537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
90538   int jresult ;
90539   int result;
90540
90541   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
90542   jresult = (int)result;
90543   return jresult;
90544 }
90545
90546
90547 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
90548   int jresult ;
90549   int result;
90550
90551   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
90552   jresult = (int)result;
90553   return jresult;
90554 }
90555
90556
90557 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
90558   int jresult ;
90559   int result;
90560
90561   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
90562   jresult = (int)result;
90563   return jresult;
90564 }
90565
90566
90567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
90568   void * jresult ;
90569   Dali::Toolkit::ToggleButton::Property *result = 0 ;
90570
90571   {
90572     try {
90573       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
90574     } catch (std::out_of_range& e) {
90575       {
90576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90577       };
90578     } catch (std::exception& e) {
90579       {
90580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90581       };
90582     } catch (Dali::DaliException e) {
90583       {
90584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90585       };
90586     } catch (...) {
90587       {
90588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90589       };
90590     }
90591   }
90592
90593   jresult = (void *)result;
90594   return jresult;
90595 }
90596
90597
90598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
90599   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
90600
90601   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
90602   {
90603     try {
90604       delete arg1;
90605     } catch (std::out_of_range& e) {
90606       {
90607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90608       };
90609     } catch (std::exception& e) {
90610       {
90611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90612       };
90613     } catch (Dali::DaliException e) {
90614       {
90615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90616       };
90617     } catch (...) {
90618       {
90619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90620       };
90621     }
90622   }
90623
90624 }
90625
90626
90627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
90628   void * jresult ;
90629   Dali::Toolkit::ToggleButton *result = 0 ;
90630
90631   {
90632     try {
90633       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
90634     } catch (std::out_of_range& e) {
90635       {
90636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90637       };
90638     } catch (std::exception& e) {
90639       {
90640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90641       };
90642     } catch (Dali::DaliException e) {
90643       {
90644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90645       };
90646     } catch (...) {
90647       {
90648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90649       };
90650     }
90651   }
90652
90653   jresult = (void *)result;
90654   return jresult;
90655 }
90656
90657
90658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
90659   void * jresult ;
90660   Dali::Toolkit::ToggleButton *arg1 = 0 ;
90661   Dali::Toolkit::ToggleButton *result = 0 ;
90662
90663   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90664   if (!arg1) {
90665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
90666     return 0;
90667   }
90668   {
90669     try {
90670       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
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_ToggleButton_Assign(void * jarg1, void * jarg2) {
90696   void * jresult ;
90697   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
90698   Dali::Toolkit::ToggleButton *arg2 = 0 ;
90699   Dali::Toolkit::ToggleButton *result = 0 ;
90700
90701   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90702   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
90703   if (!arg2) {
90704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
90705     return 0;
90706   }
90707   {
90708     try {
90709       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
90710     } catch (std::out_of_range& e) {
90711       {
90712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90713       };
90714     } catch (std::exception& e) {
90715       {
90716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90717       };
90718     } catch (Dali::DaliException e) {
90719       {
90720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90721       };
90722     } catch (...) {
90723       {
90724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90725       };
90726     }
90727   }
90728
90729   jresult = (void *)result;
90730   return jresult;
90731 }
90732
90733
90734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
90735   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
90736
90737   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90738   {
90739     try {
90740       delete arg1;
90741     } catch (std::out_of_range& e) {
90742       {
90743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90744       };
90745     } catch (std::exception& e) {
90746       {
90747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90748       };
90749     } catch (Dali::DaliException e) {
90750       {
90751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90752       };
90753     } catch (...) {
90754       {
90755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90756       };
90757     }
90758   }
90759
90760 }
90761
90762
90763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
90764   void * jresult ;
90765   Dali::Toolkit::ToggleButton result;
90766
90767   {
90768     try {
90769       result = Dali::Toolkit::ToggleButton::New();
90770     } catch (std::out_of_range& e) {
90771       {
90772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90773       };
90774     } catch (std::exception& e) {
90775       {
90776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90777       };
90778     } catch (Dali::DaliException e) {
90779       {
90780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90781       };
90782     } catch (...) {
90783       {
90784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90785       };
90786     }
90787   }
90788
90789   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
90790   return jresult;
90791 }
90792
90793
90794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
90795   void * jresult ;
90796   Dali::BaseHandle arg1 ;
90797   Dali::BaseHandle *argp1 ;
90798   Dali::Toolkit::ToggleButton result;
90799
90800   argp1 = (Dali::BaseHandle *)jarg1;
90801   if (!argp1) {
90802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90803     return 0;
90804   }
90805   arg1 = *argp1;
90806   {
90807     try {
90808       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
90809     } catch (std::out_of_range& e) {
90810       {
90811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90812       };
90813     } catch (std::exception& e) {
90814       {
90815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90816       };
90817     } catch (Dali::DaliException e) {
90818       {
90819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90820       };
90821     } catch (...) {
90822       {
90823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90824       };
90825     }
90826   }
90827
90828   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
90829   return jresult;
90830 }
90831
90832
90833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
90834   void * jresult ;
90835   Dali::Toolkit::Visual::Base *result = 0 ;
90836
90837   {
90838     try {
90839       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
90840     } catch (std::out_of_range& e) {
90841       {
90842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90843       };
90844     } catch (std::exception& e) {
90845       {
90846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90847       };
90848     } catch (Dali::DaliException e) {
90849       {
90850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90851       };
90852     } catch (...) {
90853       {
90854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90855       };
90856     }
90857   }
90858
90859   jresult = (void *)result;
90860   return jresult;
90861 }
90862
90863
90864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
90865   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90866
90867   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90868   {
90869     try {
90870       delete arg1;
90871     } catch (std::out_of_range& e) {
90872       {
90873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90874       };
90875     } catch (std::exception& e) {
90876       {
90877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90878       };
90879     } catch (Dali::DaliException e) {
90880       {
90881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90882       };
90883     } catch (...) {
90884       {
90885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90886       };
90887     }
90888   }
90889
90890 }
90891
90892
90893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
90894   void * jresult ;
90895   Dali::Toolkit::Visual::Base *arg1 = 0 ;
90896   Dali::Toolkit::Visual::Base *result = 0 ;
90897
90898   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90899   if (!arg1) {
90900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
90901     return 0;
90902   }
90903   {
90904     try {
90905       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*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 = (void *)result;
90926   return jresult;
90927 }
90928
90929
90930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
90931   void * jresult ;
90932   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90933   Dali::Toolkit::Visual::Base *arg2 = 0 ;
90934   Dali::Toolkit::Visual::Base *result = 0 ;
90935
90936   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90937   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
90938   if (!arg2) {
90939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
90940     return 0;
90941   }
90942   {
90943     try {
90944       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
90945     } catch (std::out_of_range& e) {
90946       {
90947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90948       };
90949     } catch (std::exception& e) {
90950       {
90951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90952       };
90953     } catch (Dali::DaliException e) {
90954       {
90955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90956       };
90957     } catch (...) {
90958       {
90959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90960       };
90961     }
90962   }
90963
90964   jresult = (void *)result;
90965   return jresult;
90966 }
90967
90968
90969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
90970   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90971   std::string *arg2 = 0 ;
90972
90973   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90974   if (!jarg2) {
90975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90976     return ;
90977   }
90978   std::string arg2_str(jarg2);
90979   arg2 = &arg2_str;
90980   {
90981     try {
90982       (arg1)->SetName((std::string const &)*arg2);
90983     } catch (std::out_of_range& e) {
90984       {
90985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90986       };
90987     } catch (std::exception& e) {
90988       {
90989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90990       };
90991     } catch (Dali::DaliException e) {
90992       {
90993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90994       };
90995     } catch (...) {
90996       {
90997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90998       };
90999     }
91000   }
91001
91002
91003   //argout typemap for const std::string&
91004
91005 }
91006
91007
91008 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
91009   char * jresult ;
91010   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91011   std::string *result = 0 ;
91012
91013   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91014   {
91015     try {
91016       result = (std::string *) &(arg1)->GetName();
91017     } catch (std::out_of_range& e) {
91018       {
91019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91020       };
91021     } catch (std::exception& e) {
91022       {
91023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91024       };
91025     } catch (Dali::DaliException e) {
91026       {
91027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91028       };
91029     } catch (...) {
91030       {
91031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91032       };
91033     }
91034   }
91035
91036   jresult = SWIG_csharp_string_callback(result->c_str());
91037   return jresult;
91038 }
91039
91040
91041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
91042   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91043   Dali::Property::Map *arg2 = 0 ;
91044   Dali::Size arg3 ;
91045   Dali::Size *argp3 ;
91046
91047   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91048   arg2 = (Dali::Property::Map *)jarg2;
91049   if (!arg2) {
91050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
91051     return ;
91052   }
91053   argp3 = (Dali::Size *)jarg3;
91054   if (!argp3) {
91055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
91056     return ;
91057   }
91058   arg3 = *argp3;
91059   {
91060     try {
91061       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
91062     } catch (std::out_of_range& e) {
91063       {
91064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91065       };
91066     } catch (std::exception& e) {
91067       {
91068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91069       };
91070     } catch (Dali::DaliException e) {
91071       {
91072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91073       };
91074     } catch (...) {
91075       {
91076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91077       };
91078     }
91079   }
91080
91081 }
91082
91083
91084 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
91085   float jresult ;
91086   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91087   float arg2 ;
91088   float result;
91089
91090   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91091   arg2 = (float)jarg2;
91092   {
91093     try {
91094       result = (float)(arg1)->GetHeightForWidth(arg2);
91095     } catch (std::out_of_range& e) {
91096       {
91097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91098       };
91099     } catch (std::exception& e) {
91100       {
91101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91102       };
91103     } catch (Dali::DaliException e) {
91104       {
91105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91106       };
91107     } catch (...) {
91108       {
91109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91110       };
91111     }
91112   }
91113
91114   jresult = result;
91115   return jresult;
91116 }
91117
91118
91119 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
91120   float jresult ;
91121   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91122   float arg2 ;
91123   float result;
91124
91125   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91126   arg2 = (float)jarg2;
91127   {
91128     try {
91129       result = (float)(arg1)->GetWidthForHeight(arg2);
91130     } catch (std::out_of_range& e) {
91131       {
91132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91133       };
91134     } catch (std::exception& e) {
91135       {
91136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91137       };
91138     } catch (Dali::DaliException e) {
91139       {
91140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91141       };
91142     } catch (...) {
91143       {
91144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91145       };
91146     }
91147   }
91148
91149   jresult = result;
91150   return jresult;
91151 }
91152
91153
91154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
91155   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91156   Dali::Vector2 *arg2 = 0 ;
91157
91158   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91159   arg2 = (Dali::Vector2 *)jarg2;
91160   if (!arg2) {
91161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
91162     return ;
91163   }
91164   {
91165     try {
91166       (arg1)->GetNaturalSize(*arg2);
91167     } catch (std::out_of_range& e) {
91168       {
91169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91170       };
91171     } catch (std::exception& e) {
91172       {
91173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91174       };
91175     } catch (Dali::DaliException e) {
91176       {
91177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91178       };
91179     } catch (...) {
91180       {
91181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91182       };
91183     }
91184   }
91185
91186 }
91187
91188
91189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
91190   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91191   float arg2 ;
91192
91193   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91194   arg2 = (int)jarg2;
91195   {
91196     try {
91197       (arg1)->SetDepthIndex(arg2);
91198     } catch (std::out_of_range& e) {
91199       {
91200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91201       };
91202     } catch (std::exception& e) {
91203       {
91204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91205       };
91206     } catch (Dali::DaliException e) {
91207       {
91208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91209       };
91210     } catch (...) {
91211       {
91212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91213       };
91214     }
91215   }
91216
91217 }
91218
91219
91220 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
91221   int jresult ;
91222   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91223   int result;
91224
91225   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91226   {
91227     try {
91228       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
91229     } catch (std::out_of_range& e) {
91230       {
91231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91232       };
91233     } catch (std::exception& e) {
91234       {
91235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91236       };
91237     } catch (Dali::DaliException e) {
91238       {
91239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91240       };
91241     } catch (...) {
91242       {
91243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91244       };
91245     }
91246   }
91247
91248   jresult = result;
91249   return jresult;
91250 }
91251
91252
91253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
91254   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91255   Dali::Property::Map *arg2 = 0 ;
91256
91257   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91258   arg2 = (Dali::Property::Map *)jarg2;
91259   if (!arg2) {
91260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
91261     return ;
91262   }
91263   {
91264     try {
91265       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
91266     } catch (std::out_of_range& e) {
91267       {
91268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91269       };
91270     } catch (std::exception& e) {
91271       {
91272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91273       };
91274     } catch (Dali::DaliException e) {
91275       {
91276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91277       };
91278     } catch (...) {
91279       {
91280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91281       };
91282     }
91283   }
91284
91285 }
91286
91287
91288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_2(void * jarg1) {
91289   void * jresult ;
91290   Dali::Toolkit::Internal::Visual::Base *arg1 = (Dali::Toolkit::Internal::Visual::Base *) 0 ;
91291   Dali::Toolkit::Visual::Base *result = 0 ;
91292
91293   arg1 = (Dali::Toolkit::Internal::Visual::Base *)jarg1;
91294   {
91295     try {
91296       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base(arg1);
91297     } catch (std::out_of_range& e) {
91298       {
91299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91300       };
91301     } catch (std::exception& e) {
91302       {
91303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91304       };
91305     } catch (Dali::DaliException e) {
91306       {
91307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91308       };
91309     } catch (...) {
91310       {
91311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91312       };
91313     }
91314   }
91315
91316   jresult = (void *)result;
91317   return jresult;
91318 }
91319
91320
91321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
91322   void * jresult ;
91323   Dali::Toolkit::VisualFactory result;
91324
91325   {
91326     try {
91327       result = Dali::Toolkit::VisualFactory::Get();
91328     } catch (std::out_of_range& e) {
91329       {
91330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91331       };
91332     } catch (std::exception& e) {
91333       {
91334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91335       };
91336     } catch (Dali::DaliException e) {
91337       {
91338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91339       };
91340     } catch (...) {
91341       {
91342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91343       };
91344     }
91345   }
91346
91347   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
91348   return jresult;
91349 }
91350
91351
91352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
91353   void * jresult ;
91354   Dali::Toolkit::VisualFactory *result = 0 ;
91355
91356   {
91357     try {
91358       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
91359     } catch (std::out_of_range& e) {
91360       {
91361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91362       };
91363     } catch (std::exception& e) {
91364       {
91365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91366       };
91367     } catch (Dali::DaliException e) {
91368       {
91369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91370       };
91371     } catch (...) {
91372       {
91373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91374       };
91375     }
91376   }
91377
91378   jresult = (void *)result;
91379   return jresult;
91380 }
91381
91382
91383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
91384   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91385
91386   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91387   {
91388     try {
91389       delete arg1;
91390     } catch (std::out_of_range& e) {
91391       {
91392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91393       };
91394     } catch (std::exception& e) {
91395       {
91396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91397       };
91398     } catch (Dali::DaliException e) {
91399       {
91400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91401       };
91402     } catch (...) {
91403       {
91404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91405       };
91406     }
91407   }
91408
91409 }
91410
91411
91412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
91413   void * jresult ;
91414   Dali::Toolkit::VisualFactory *arg1 = 0 ;
91415   Dali::Toolkit::VisualFactory *result = 0 ;
91416
91417   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91418   if (!arg1) {
91419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91420     return 0;
91421   }
91422   {
91423     try {
91424       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
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 = (void *)result;
91445   return jresult;
91446 }
91447
91448
91449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
91450   void * jresult ;
91451   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91452   Dali::Toolkit::VisualFactory *arg2 = 0 ;
91453   Dali::Toolkit::VisualFactory *result = 0 ;
91454
91455   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91456   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
91457   if (!arg2) {
91458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91459     return 0;
91460   }
91461   {
91462     try {
91463       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
91464     } catch (std::out_of_range& e) {
91465       {
91466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91467       };
91468     } catch (std::exception& e) {
91469       {
91470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91471       };
91472     } catch (Dali::DaliException e) {
91473       {
91474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91475       };
91476     } catch (...) {
91477       {
91478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91479       };
91480     }
91481   }
91482
91483   jresult = (void *)result;
91484   return jresult;
91485 }
91486
91487
91488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
91489   void * jresult ;
91490   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91491   Dali::Property::Map *arg2 = 0 ;
91492   Dali::Toolkit::Visual::Base result;
91493
91494   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91495   arg2 = (Dali::Property::Map *)jarg2;
91496   if (!arg2) {
91497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
91498     return 0;
91499   }
91500   {
91501     try {
91502       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
91503     } catch (std::out_of_range& e) {
91504       {
91505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91506       };
91507     } catch (std::exception& e) {
91508       {
91509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91510       };
91511     } catch (Dali::DaliException e) {
91512       {
91513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91514       };
91515     } catch (...) {
91516       {
91517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91518       };
91519     }
91520   }
91521
91522   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91523   return jresult;
91524 }
91525
91526
91527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
91528   void * jresult ;
91529   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91530   Dali::Image *arg2 = 0 ;
91531   Dali::Toolkit::Visual::Base result;
91532
91533   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91534   arg2 = (Dali::Image *)jarg2;
91535   if (!arg2) {
91536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
91537     return 0;
91538   }
91539   {
91540     try {
91541       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
91542     } catch (std::out_of_range& e) {
91543       {
91544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91545       };
91546     } catch (std::exception& e) {
91547       {
91548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91549       };
91550     } catch (Dali::DaliException e) {
91551       {
91552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91553       };
91554     } catch (...) {
91555       {
91556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91557       };
91558     }
91559   }
91560
91561   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91562   return jresult;
91563 }
91564
91565
91566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
91567   void * jresult ;
91568   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91569   std::string *arg2 = 0 ;
91570   Dali::ImageDimensions arg3 ;
91571   Dali::ImageDimensions *argp3 ;
91572   Dali::Toolkit::Visual::Base result;
91573
91574   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91575   if (!jarg2) {
91576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91577     return 0;
91578   }
91579   std::string arg2_str(jarg2);
91580   arg2 = &arg2_str;
91581   argp3 = (Dali::ImageDimensions *)jarg3;
91582   if (!argp3) {
91583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91584     return 0;
91585   }
91586   arg3 = *argp3;
91587   {
91588     try {
91589       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
91590     } catch (std::out_of_range& e) {
91591       {
91592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91593       };
91594     } catch (std::exception& e) {
91595       {
91596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91597       };
91598     } catch (Dali::DaliException e) {
91599       {
91600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91601       };
91602     } catch (...) {
91603       {
91604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91605       };
91606     }
91607   }
91608
91609   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91610
91611   //argout typemap for const std::string&
91612
91613   return jresult;
91614 }
91615
91616
91617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
91618   void * jresult ;
91619   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91620
91621   {
91622     try {
91623       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
91624     } catch (std::out_of_range& e) {
91625       {
91626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91627       };
91628     } catch (std::exception& e) {
91629       {
91630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91631       };
91632     } catch (Dali::DaliException e) {
91633       {
91634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91635       };
91636     } catch (...) {
91637       {
91638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91639       };
91640     }
91641   }
91642
91643   jresult = (void *)result;
91644   return jresult;
91645 }
91646
91647
91648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
91649   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91650
91651   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91652   {
91653     try {
91654       delete arg1;
91655     } catch (std::out_of_range& e) {
91656       {
91657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91658       };
91659     } catch (std::exception& e) {
91660       {
91661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91662       };
91663     } catch (Dali::DaliException e) {
91664       {
91665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91666       };
91667     } catch (...) {
91668       {
91669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91670       };
91671     }
91672   }
91673
91674 }
91675
91676
91677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
91678   void * jresult ;
91679   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
91680   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91681
91682   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91683   if (!arg1) {
91684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
91685     return 0;
91686   }
91687   {
91688     try {
91689       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
91690     } catch (std::out_of_range& e) {
91691       {
91692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91693       };
91694     } catch (std::exception& e) {
91695       {
91696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91697       };
91698     } catch (Dali::DaliException e) {
91699       {
91700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91701       };
91702     } catch (...) {
91703       {
91704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91705       };
91706     }
91707   }
91708
91709   jresult = (void *)result;
91710   return jresult;
91711 }
91712
91713
91714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
91715   void * jresult ;
91716   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91717   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
91718   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91719
91720   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91721   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
91722   if (!arg2) {
91723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
91724     return 0;
91725   }
91726   {
91727     try {
91728       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
91729     } catch (std::out_of_range& e) {
91730       {
91731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91732       };
91733     } catch (std::exception& e) {
91734       {
91735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91736       };
91737     } catch (Dali::DaliException e) {
91738       {
91739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91740       };
91741     } catch (...) {
91742       {
91743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91744       };
91745     }
91746   }
91747
91748   jresult = (void *)result;
91749   return jresult;
91750 }
91751
91752
91753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
91754   void * jresult ;
91755   Dali::Toolkit::AsyncImageLoader result;
91756
91757   {
91758     try {
91759       result = Dali::Toolkit::AsyncImageLoader::New();
91760     } catch (std::out_of_range& e) {
91761       {
91762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91763       };
91764     } catch (std::exception& e) {
91765       {
91766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91767       };
91768     } catch (Dali::DaliException e) {
91769       {
91770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91771       };
91772     } catch (...) {
91773       {
91774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91775       };
91776     }
91777   }
91778
91779   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
91780   return jresult;
91781 }
91782
91783
91784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
91785   void * jresult ;
91786   Dali::BaseHandle arg1 ;
91787   Dali::BaseHandle *argp1 ;
91788   Dali::Toolkit::AsyncImageLoader result;
91789
91790   argp1 = (Dali::BaseHandle *)jarg1;
91791   if (!argp1) {
91792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
91793     return 0;
91794   }
91795   arg1 = *argp1;
91796   {
91797     try {
91798       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
91799     } catch (std::out_of_range& e) {
91800       {
91801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91802       };
91803     } catch (std::exception& e) {
91804       {
91805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91806       };
91807     } catch (Dali::DaliException e) {
91808       {
91809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91810       };
91811     } catch (...) {
91812       {
91813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91814       };
91815     }
91816   }
91817
91818   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
91819   return jresult;
91820 }
91821
91822
91823 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
91824   unsigned int jresult ;
91825   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91826   std::string *arg2 = 0 ;
91827   uint32_t result;
91828
91829   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91830   if (!jarg2) {
91831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91832     return 0;
91833   }
91834   std::string arg2_str(jarg2);
91835   arg2 = &arg2_str;
91836   {
91837     try {
91838       result = (arg1)->Load((std::string const &)*arg2);
91839     } catch (std::out_of_range& e) {
91840       {
91841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91842       };
91843     } catch (std::exception& e) {
91844       {
91845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91846       };
91847     } catch (Dali::DaliException e) {
91848       {
91849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91850       };
91851     } catch (...) {
91852       {
91853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91854       };
91855     }
91856   }
91857
91858   jresult = result;
91859
91860   //argout typemap for const std::string&
91861
91862   return jresult;
91863 }
91864
91865
91866 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
91867   unsigned int jresult ;
91868   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91869   std::string *arg2 = 0 ;
91870   Dali::ImageDimensions arg3 ;
91871   Dali::ImageDimensions *argp3 ;
91872   uint32_t result;
91873
91874   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91875   if (!jarg2) {
91876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91877     return 0;
91878   }
91879   std::string arg2_str(jarg2);
91880   arg2 = &arg2_str;
91881   argp3 = (Dali::ImageDimensions *)jarg3;
91882   if (!argp3) {
91883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91884     return 0;
91885   }
91886   arg3 = *argp3;
91887   {
91888     try {
91889       result = (arg1)->Load((std::string const &)*arg2,arg3);
91890     } catch (std::out_of_range& e) {
91891       {
91892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91893       };
91894     } catch (std::exception& e) {
91895       {
91896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91897       };
91898     } catch (Dali::DaliException e) {
91899       {
91900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91901       };
91902     } catch (...) {
91903       {
91904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91905       };
91906     }
91907   }
91908
91909   jresult = result;
91910
91911   //argout typemap for const std::string&
91912
91913   return jresult;
91914 }
91915
91916
91917 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
91918   unsigned int jresult ;
91919   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91920   std::string *arg2 = 0 ;
91921   Dali::ImageDimensions arg3 ;
91922   Dali::FittingMode::Type arg4 ;
91923   Dali::SamplingMode::Type arg5 ;
91924   bool arg6 ;
91925   Dali::ImageDimensions *argp3 ;
91926   uint32_t result;
91927
91928   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91929   if (!jarg2) {
91930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91931     return 0;
91932   }
91933   std::string arg2_str(jarg2);
91934   arg2 = &arg2_str;
91935   argp3 = (Dali::ImageDimensions *)jarg3;
91936   if (!argp3) {
91937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91938     return 0;
91939   }
91940   arg3 = *argp3;
91941   arg4 = (Dali::FittingMode::Type)jarg4;
91942   arg5 = (Dali::SamplingMode::Type)jarg5;
91943   arg6 = jarg6 ? true : false;
91944   {
91945     try {
91946       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
91947     } catch (std::out_of_range& e) {
91948       {
91949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91950       };
91951     } catch (std::exception& e) {
91952       {
91953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91954       };
91955     } catch (Dali::DaliException e) {
91956       {
91957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91958       };
91959     } catch (...) {
91960       {
91961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91962       };
91963     }
91964   }
91965
91966   jresult = result;
91967
91968   //argout typemap for const std::string&
91969
91970   return jresult;
91971 }
91972
91973
91974 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
91975   unsigned int jresult ;
91976   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91977   uint32_t arg2 ;
91978   bool result;
91979
91980   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91981   arg2 = (uint32_t)jarg2;
91982   {
91983     try {
91984       result = (bool)(arg1)->Cancel(arg2);
91985     } catch (std::out_of_range& e) {
91986       {
91987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91988       };
91989     } catch (std::exception& e) {
91990       {
91991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91992       };
91993     } catch (Dali::DaliException e) {
91994       {
91995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91996       };
91997     } catch (...) {
91998       {
91999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92000       };
92001     }
92002   }
92003
92004   jresult = result;
92005   return jresult;
92006 }
92007
92008
92009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
92010   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92011
92012   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92013   {
92014     try {
92015       (arg1)->CancelAll();
92016     } catch (std::out_of_range& e) {
92017       {
92018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92019       };
92020     } catch (std::exception& e) {
92021       {
92022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92023       };
92024     } catch (Dali::DaliException e) {
92025       {
92026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92027       };
92028     } catch (...) {
92029       {
92030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92031       };
92032     }
92033   }
92034
92035 }
92036
92037
92038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
92039   void * jresult ;
92040   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92041   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
92042
92043   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92044   {
92045     try {
92046       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
92047     } catch (std::out_of_range& e) {
92048       {
92049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92050       };
92051     } catch (std::exception& e) {
92052       {
92053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92054       };
92055     } catch (Dali::DaliException e) {
92056       {
92057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92058       };
92059     } catch (...) {
92060       {
92061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92062       };
92063     }
92064   }
92065
92066   jresult = (void *)result;
92067   return jresult;
92068 }
92069
92070
92071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_2(void * jarg1) {
92072   void * jresult ;
92073   Dali::Toolkit::Internal::AsyncImageLoader *arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *) 0 ;
92074   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92075
92076   arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *)jarg1;
92077   {
92078     try {
92079       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader(arg1);
92080     } catch (std::out_of_range& e) {
92081       {
92082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92083       };
92084     } catch (std::exception& e) {
92085       {
92086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92087       };
92088     } catch (Dali::DaliException e) {
92089       {
92090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92091       };
92092     } catch (...) {
92093       {
92094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92095       };
92096     }
92097   }
92098
92099   jresult = (void *)result;
92100   return jresult;
92101 }
92102
92103
92104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
92105   void * jresult ;
92106   std::string *arg1 = 0 ;
92107   Dali::PixelData result;
92108
92109   if (!jarg1) {
92110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92111     return 0;
92112   }
92113   std::string arg1_str(jarg1);
92114   arg1 = &arg1_str;
92115   {
92116     try {
92117       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
92118     } catch (std::out_of_range& e) {
92119       {
92120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92121       };
92122     } catch (std::exception& e) {
92123       {
92124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92125       };
92126     } catch (Dali::DaliException e) {
92127       {
92128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92129       };
92130     } catch (...) {
92131       {
92132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92133       };
92134     }
92135   }
92136
92137   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92138
92139   //argout typemap for const std::string&
92140
92141   return jresult;
92142 }
92143
92144
92145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
92146   void * jresult ;
92147   std::string *arg1 = 0 ;
92148   Dali::ImageDimensions arg2 ;
92149   Dali::ImageDimensions *argp2 ;
92150   Dali::PixelData result;
92151
92152   if (!jarg1) {
92153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92154     return 0;
92155   }
92156   std::string arg1_str(jarg1);
92157   arg1 = &arg1_str;
92158   argp2 = (Dali::ImageDimensions *)jarg2;
92159   if (!argp2) {
92160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92161     return 0;
92162   }
92163   arg2 = *argp2;
92164   {
92165     try {
92166       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
92167     } catch (std::out_of_range& e) {
92168       {
92169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92170       };
92171     } catch (std::exception& e) {
92172       {
92173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92174       };
92175     } catch (Dali::DaliException e) {
92176       {
92177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92178       };
92179     } catch (...) {
92180       {
92181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92182       };
92183     }
92184   }
92185
92186   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92187
92188   //argout typemap for const std::string&
92189
92190   return jresult;
92191 }
92192
92193
92194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
92195   void * jresult ;
92196   std::string *arg1 = 0 ;
92197   Dali::ImageDimensions arg2 ;
92198   Dali::FittingMode::Type arg3 ;
92199   Dali::SamplingMode::Type arg4 ;
92200   bool arg5 ;
92201   Dali::ImageDimensions *argp2 ;
92202   Dali::PixelData result;
92203
92204   if (!jarg1) {
92205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92206     return 0;
92207   }
92208   std::string arg1_str(jarg1);
92209   arg1 = &arg1_str;
92210   argp2 = (Dali::ImageDimensions *)jarg2;
92211   if (!argp2) {
92212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92213     return 0;
92214   }
92215   arg2 = *argp2;
92216   arg3 = (Dali::FittingMode::Type)jarg3;
92217   arg4 = (Dali::SamplingMode::Type)jarg4;
92218   arg5 = jarg5 ? true : false;
92219   {
92220     try {
92221       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
92222     } catch (std::out_of_range& e) {
92223       {
92224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92225       };
92226     } catch (std::exception& e) {
92227       {
92228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92229       };
92230     } catch (Dali::DaliException e) {
92231       {
92232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92233       };
92234     } catch (...) {
92235       {
92236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92237       };
92238     }
92239   }
92240
92241   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92242
92243   //argout typemap for const std::string&
92244
92245   return jresult;
92246 }
92247
92248
92249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
92250   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92251
92252   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92253   {
92254     try {
92255       delete arg1;
92256     } catch (std::out_of_range& e) {
92257       {
92258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92259       };
92260     } catch (std::exception& e) {
92261       {
92262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92263       };
92264     } catch (Dali::DaliException e) {
92265       {
92266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92267       };
92268     } catch (...) {
92269       {
92270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92271       };
92272     }
92273   }
92274
92275 }
92276
92277
92278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
92279   void * jresult ;
92280   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92281   Dali::Actor arg2 ;
92282   Dali::Actor arg3 ;
92283   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
92284   Dali::Actor *argp2 ;
92285   Dali::Actor *argp3 ;
92286   Dali::Actor result;
92287
92288   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92289   argp2 = (Dali::Actor *)jarg2;
92290   if (!argp2) {
92291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92292     return 0;
92293   }
92294   arg2 = *argp2;
92295   argp3 = (Dali::Actor *)jarg3;
92296   if (!argp3) {
92297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92298     return 0;
92299   }
92300   arg3 = *argp3;
92301   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
92302   {
92303     try {
92304       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
92305     } catch (std::out_of_range& e) {
92306       {
92307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92308       };
92309     } catch (std::exception& e) {
92310       {
92311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92312       };
92313     } catch (Dali::DaliException e) {
92314       {
92315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92316       };
92317     } catch (...) {
92318       {
92319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92320       };
92321     }
92322   }
92323
92324   jresult = new Dali::Actor((const Dali::Actor &)result);
92325   return jresult;
92326 }
92327
92328
92329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
92330   void * jresult ;
92331   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
92332
92333   {
92334     try {
92335       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
92336     } catch (std::out_of_range& e) {
92337       {
92338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92339       };
92340     } catch (std::exception& e) {
92341       {
92342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92343       };
92344     } catch (Dali::DaliException e) {
92345       {
92346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92347       };
92348     } catch (...) {
92349       {
92350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92351       };
92352     }
92353   }
92354
92355   jresult = (void *)result;
92356   return jresult;
92357 }
92358
92359
92360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
92361   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
92362   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
92363   if (director) {
92364     director->swig_connect_director(callback0);
92365   }
92366 }
92367
92368
92369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
92370   KeyboardFocusManager arg1 ;
92371   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
92372   KeyboardFocusManager *argp1 ;
92373
92374   argp1 = (KeyboardFocusManager *)jarg1;
92375   if (!argp1) {
92376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
92377     return ;
92378   }
92379   arg1 = *argp1;
92380   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
92381   if (!arg2) {
92382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
92383     return ;
92384   }
92385   {
92386     try {
92387       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
92388     } catch (std::out_of_range& e) {
92389       {
92390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92391       };
92392     } catch (std::exception& e) {
92393       {
92394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92395       };
92396     } catch (Dali::DaliException e) {
92397       {
92398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92399       };
92400     } catch (...) {
92401       {
92402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92403       };
92404     }
92405   }
92406
92407 }
92408
92409
92410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
92411   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92412
92413   arg1 = (std::vector< unsigned int > *)jarg1;
92414   {
92415     try {
92416       (arg1)->clear();
92417     } catch (std::out_of_range& e) {
92418       {
92419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92420       };
92421     } catch (std::exception& e) {
92422       {
92423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92424       };
92425     } catch (Dali::DaliException e) {
92426       {
92427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92428       };
92429     } catch (...) {
92430       {
92431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92432       };
92433     }
92434   }
92435
92436 }
92437
92438
92439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
92440   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92441   unsigned int *arg2 = 0 ;
92442   unsigned int temp2 ;
92443
92444   arg1 = (std::vector< unsigned int > *)jarg1;
92445   temp2 = (unsigned int)jarg2;
92446   arg2 = &temp2;
92447   {
92448     try {
92449       (arg1)->push_back((unsigned int const &)*arg2);
92450     } catch (std::out_of_range& e) {
92451       {
92452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92453       };
92454     } catch (std::exception& e) {
92455       {
92456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92457       };
92458     } catch (Dali::DaliException e) {
92459       {
92460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92461       };
92462     } catch (...) {
92463       {
92464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92465       };
92466     }
92467   }
92468
92469 }
92470
92471
92472 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
92473   unsigned long jresult ;
92474   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92475   std::vector< unsigned int >::size_type result;
92476
92477   arg1 = (std::vector< unsigned int > *)jarg1;
92478   {
92479     try {
92480       result = ((std::vector< unsigned int > const *)arg1)->size();
92481     } catch (std::out_of_range& e) {
92482       {
92483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92484       };
92485     } catch (std::exception& e) {
92486       {
92487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92488       };
92489     } catch (Dali::DaliException e) {
92490       {
92491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92492       };
92493     } catch (...) {
92494       {
92495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92496       };
92497     }
92498   }
92499
92500   jresult = (unsigned long)result;
92501   return jresult;
92502 }
92503
92504
92505 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
92506   unsigned long jresult ;
92507   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92508   std::vector< unsigned int >::size_type result;
92509
92510   arg1 = (std::vector< unsigned int > *)jarg1;
92511   {
92512     try {
92513       result = ((std::vector< unsigned int > const *)arg1)->capacity();
92514     } catch (std::out_of_range& e) {
92515       {
92516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92517       };
92518     } catch (std::exception& e) {
92519       {
92520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92521       };
92522     } catch (Dali::DaliException e) {
92523       {
92524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92525       };
92526     } catch (...) {
92527       {
92528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92529       };
92530     }
92531   }
92532
92533   jresult = (unsigned long)result;
92534   return jresult;
92535 }
92536
92537
92538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
92539   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92540   std::vector< unsigned int >::size_type arg2 ;
92541
92542   arg1 = (std::vector< unsigned int > *)jarg1;
92543   arg2 = (std::vector< unsigned int >::size_type)jarg2;
92544   {
92545     try {
92546       (arg1)->reserve(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 void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
92570   void * jresult ;
92571   std::vector< unsigned int > *result = 0 ;
92572
92573   {
92574     try {
92575       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
92576     } catch (std::out_of_range& e) {
92577       {
92578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92579       };
92580     } catch (std::exception& e) {
92581       {
92582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92583       };
92584     } catch (Dali::DaliException e) {
92585       {
92586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92587       };
92588     } catch (...) {
92589       {
92590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92591       };
92592     }
92593   }
92594
92595   jresult = (void *)result;
92596   return jresult;
92597 }
92598
92599
92600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
92601   void * jresult ;
92602   std::vector< unsigned int > *arg1 = 0 ;
92603   std::vector< unsigned int > *result = 0 ;
92604
92605   arg1 = (std::vector< unsigned int > *)jarg1;
92606   if (!arg1) {
92607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92608     return 0;
92609   }
92610   {
92611     try {
92612       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
92613     } catch (std::out_of_range& e) {
92614       {
92615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92616       };
92617     } catch (std::exception& e) {
92618       {
92619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92620       };
92621     } catch (Dali::DaliException e) {
92622       {
92623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92624       };
92625     } catch (...) {
92626       {
92627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92628       };
92629     }
92630   }
92631
92632   jresult = (void *)result;
92633   return jresult;
92634 }
92635
92636
92637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
92638   void * jresult ;
92639   int arg1 ;
92640   std::vector< unsigned int > *result = 0 ;
92641
92642   arg1 = (int)jarg1;
92643   {
92644     try {
92645       try {
92646         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
92647       }
92648       catch(std::out_of_range &_e) {
92649         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92650         return 0;
92651       }
92652
92653     } catch (std::out_of_range& e) {
92654       {
92655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92656       };
92657     } catch (std::exception& e) {
92658       {
92659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92660       };
92661     } catch (Dali::DaliException e) {
92662       {
92663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92664       };
92665     } catch (...) {
92666       {
92667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92668       };
92669     }
92670   }
92671
92672   jresult = (void *)result;
92673   return jresult;
92674 }
92675
92676
92677 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
92678   unsigned int jresult ;
92679   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92680   int arg2 ;
92681   unsigned int result;
92682
92683   arg1 = (std::vector< unsigned int > *)jarg1;
92684   arg2 = (int)jarg2;
92685   {
92686     try {
92687       try {
92688         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
92689       }
92690       catch(std::out_of_range &_e) {
92691         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92692         return 0;
92693       }
92694
92695     } catch (std::out_of_range& e) {
92696       {
92697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92698       };
92699     } catch (std::exception& e) {
92700       {
92701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92702       };
92703     } catch (Dali::DaliException e) {
92704       {
92705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92706       };
92707     } catch (...) {
92708       {
92709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92710       };
92711     }
92712   }
92713
92714   jresult = result;
92715   return jresult;
92716 }
92717
92718
92719 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
92720   unsigned int jresult ;
92721   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92722   int arg2 ;
92723   unsigned int *result = 0 ;
92724
92725   arg1 = (std::vector< unsigned int > *)jarg1;
92726   arg2 = (int)jarg2;
92727   {
92728     try {
92729       try {
92730         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
92731       }
92732       catch(std::out_of_range &_e) {
92733         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92734         return 0;
92735       }
92736
92737     } catch (std::out_of_range& e) {
92738       {
92739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92740       };
92741     } catch (std::exception& e) {
92742       {
92743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92744       };
92745     } catch (Dali::DaliException e) {
92746       {
92747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92748       };
92749     } catch (...) {
92750       {
92751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92752       };
92753     }
92754   }
92755
92756   jresult = *result;
92757   return jresult;
92758 }
92759
92760
92761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
92762   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92763   int arg2 ;
92764   unsigned int *arg3 = 0 ;
92765   unsigned int temp3 ;
92766
92767   arg1 = (std::vector< unsigned int > *)jarg1;
92768   arg2 = (int)jarg2;
92769   temp3 = (unsigned int)jarg3;
92770   arg3 = &temp3;
92771   {
92772     try {
92773       try {
92774         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
92775       }
92776       catch(std::out_of_range &_e) {
92777         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92778         return ;
92779       }
92780
92781     } catch (std::out_of_range& e) {
92782       {
92783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92784       };
92785     } catch (std::exception& e) {
92786       {
92787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92788       };
92789     } catch (Dali::DaliException e) {
92790       {
92791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92792       };
92793     } catch (...) {
92794       {
92795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92796       };
92797     }
92798   }
92799
92800 }
92801
92802
92803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
92804   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92805   std::vector< unsigned int > *arg2 = 0 ;
92806
92807   arg1 = (std::vector< unsigned int > *)jarg1;
92808   arg2 = (std::vector< unsigned int > *)jarg2;
92809   if (!arg2) {
92810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92811     return ;
92812   }
92813   {
92814     try {
92815       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
92816     } catch (std::out_of_range& e) {
92817       {
92818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92819       };
92820     } catch (std::exception& e) {
92821       {
92822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92823       };
92824     } catch (Dali::DaliException e) {
92825       {
92826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92827       };
92828     } catch (...) {
92829       {
92830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92831       };
92832     }
92833   }
92834
92835 }
92836
92837
92838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
92839   void * jresult ;
92840   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92841   int arg2 ;
92842   int arg3 ;
92843   std::vector< unsigned int > *result = 0 ;
92844
92845   arg1 = (std::vector< unsigned int > *)jarg1;
92846   arg2 = (int)jarg2;
92847   arg3 = (int)jarg3;
92848   {
92849     try {
92850       try {
92851         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
92852       }
92853       catch(std::out_of_range &_e) {
92854         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92855         return 0;
92856       }
92857       catch(std::invalid_argument &_e) {
92858         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92859         return 0;
92860       }
92861
92862     } catch (std::out_of_range& e) {
92863       {
92864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92865       };
92866     } catch (std::exception& e) {
92867       {
92868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92869       };
92870     } catch (Dali::DaliException e) {
92871       {
92872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92873       };
92874     } catch (...) {
92875       {
92876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92877       };
92878     }
92879   }
92880
92881   jresult = (void *)result;
92882   return jresult;
92883 }
92884
92885
92886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
92887   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92888   int arg2 ;
92889   unsigned int *arg3 = 0 ;
92890   unsigned int temp3 ;
92891
92892   arg1 = (std::vector< unsigned int > *)jarg1;
92893   arg2 = (int)jarg2;
92894   temp3 = (unsigned int)jarg3;
92895   arg3 = &temp3;
92896   {
92897     try {
92898       try {
92899         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
92900       }
92901       catch(std::out_of_range &_e) {
92902         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92903         return ;
92904       }
92905
92906     } catch (std::out_of_range& e) {
92907       {
92908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92909       };
92910     } catch (std::exception& e) {
92911       {
92912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92913       };
92914     } catch (Dali::DaliException e) {
92915       {
92916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92917       };
92918     } catch (...) {
92919       {
92920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92921       };
92922     }
92923   }
92924
92925 }
92926
92927
92928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
92929   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92930   int arg2 ;
92931   std::vector< unsigned int > *arg3 = 0 ;
92932
92933   arg1 = (std::vector< unsigned int > *)jarg1;
92934   arg2 = (int)jarg2;
92935   arg3 = (std::vector< unsigned int > *)jarg3;
92936   if (!arg3) {
92937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92938     return ;
92939   }
92940   {
92941     try {
92942       try {
92943         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
92944       }
92945       catch(std::out_of_range &_e) {
92946         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92947         return ;
92948       }
92949
92950     } catch (std::out_of_range& e) {
92951       {
92952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92953       };
92954     } catch (std::exception& e) {
92955       {
92956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92957       };
92958     } catch (Dali::DaliException e) {
92959       {
92960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92961       };
92962     } catch (...) {
92963       {
92964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92965       };
92966     }
92967   }
92968
92969 }
92970
92971
92972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
92973   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92974   int arg2 ;
92975
92976   arg1 = (std::vector< unsigned int > *)jarg1;
92977   arg2 = (int)jarg2;
92978   {
92979     try {
92980       try {
92981         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
92982       }
92983       catch(std::out_of_range &_e) {
92984         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92985         return ;
92986       }
92987
92988     } catch (std::out_of_range& e) {
92989       {
92990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92991       };
92992     } catch (std::exception& e) {
92993       {
92994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92995       };
92996     } catch (Dali::DaliException e) {
92997       {
92998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92999       };
93000     } catch (...) {
93001       {
93002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93003       };
93004     }
93005   }
93006
93007 }
93008
93009
93010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
93011   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93012   int arg2 ;
93013   int arg3 ;
93014
93015   arg1 = (std::vector< unsigned int > *)jarg1;
93016   arg2 = (int)jarg2;
93017   arg3 = (int)jarg3;
93018   {
93019     try {
93020       try {
93021         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
93022       }
93023       catch(std::out_of_range &_e) {
93024         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93025         return ;
93026       }
93027       catch(std::invalid_argument &_e) {
93028         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93029         return ;
93030       }
93031
93032     } catch (std::out_of_range& e) {
93033       {
93034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93035       };
93036     } catch (std::exception& e) {
93037       {
93038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93039       };
93040     } catch (Dali::DaliException e) {
93041       {
93042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93043       };
93044     } catch (...) {
93045       {
93046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93047       };
93048     }
93049   }
93050
93051 }
93052
93053
93054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
93055   void * jresult ;
93056   unsigned int *arg1 = 0 ;
93057   int arg2 ;
93058   unsigned int temp1 ;
93059   std::vector< unsigned int > *result = 0 ;
93060
93061   temp1 = (unsigned int)jarg1;
93062   arg1 = &temp1;
93063   arg2 = (int)jarg2;
93064   {
93065     try {
93066       try {
93067         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
93068       }
93069       catch(std::out_of_range &_e) {
93070         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93071         return 0;
93072       }
93073
93074     } catch (std::out_of_range& e) {
93075       {
93076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93077       };
93078     } catch (std::exception& e) {
93079       {
93080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93081       };
93082     } catch (Dali::DaliException e) {
93083       {
93084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93085       };
93086     } catch (...) {
93087       {
93088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93089       };
93090     }
93091   }
93092
93093   jresult = (void *)result;
93094   return jresult;
93095 }
93096
93097
93098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
93099   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93100
93101   arg1 = (std::vector< unsigned int > *)jarg1;
93102   {
93103     try {
93104       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
93105     } catch (std::out_of_range& e) {
93106       {
93107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93108       };
93109     } catch (std::exception& e) {
93110       {
93111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93112       };
93113     } catch (Dali::DaliException e) {
93114       {
93115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93116       };
93117     } catch (...) {
93118       {
93119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93120       };
93121     }
93122   }
93123
93124 }
93125
93126
93127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
93128   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93129   int arg2 ;
93130   int arg3 ;
93131
93132   arg1 = (std::vector< unsigned int > *)jarg1;
93133   arg2 = (int)jarg2;
93134   arg3 = (int)jarg3;
93135   {
93136     try {
93137       try {
93138         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
93139       }
93140       catch(std::out_of_range &_e) {
93141         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93142         return ;
93143       }
93144       catch(std::invalid_argument &_e) {
93145         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93146         return ;
93147       }
93148
93149     } catch (std::out_of_range& e) {
93150       {
93151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93152       };
93153     } catch (std::exception& e) {
93154       {
93155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93156       };
93157     } catch (Dali::DaliException e) {
93158       {
93159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93160       };
93161     } catch (...) {
93162       {
93163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93164       };
93165     }
93166   }
93167
93168 }
93169
93170
93171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
93172   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93173   int arg2 ;
93174   std::vector< unsigned int > *arg3 = 0 ;
93175
93176   arg1 = (std::vector< unsigned int > *)jarg1;
93177   arg2 = (int)jarg2;
93178   arg3 = (std::vector< unsigned int > *)jarg3;
93179   if (!arg3) {
93180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93181     return ;
93182   }
93183   {
93184     try {
93185       try {
93186         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
93187       }
93188       catch(std::out_of_range &_e) {
93189         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93190         return ;
93191       }
93192
93193     } catch (std::out_of_range& e) {
93194       {
93195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93196       };
93197     } catch (std::exception& e) {
93198       {
93199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93200       };
93201     } catch (Dali::DaliException e) {
93202       {
93203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93204       };
93205     } catch (...) {
93206       {
93207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93208       };
93209     }
93210   }
93211
93212 }
93213
93214
93215 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
93216   unsigned int jresult ;
93217   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93218   unsigned int *arg2 = 0 ;
93219   unsigned int temp2 ;
93220   bool result;
93221
93222   arg1 = (std::vector< unsigned int > *)jarg1;
93223   temp2 = (unsigned int)jarg2;
93224   arg2 = &temp2;
93225   {
93226     try {
93227       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
93228     } catch (std::out_of_range& e) {
93229       {
93230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93231       };
93232     } catch (std::exception& e) {
93233       {
93234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93235       };
93236     } catch (Dali::DaliException e) {
93237       {
93238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93239       };
93240     } catch (...) {
93241       {
93242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93243       };
93244     }
93245   }
93246
93247   jresult = result;
93248   return jresult;
93249 }
93250
93251
93252 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
93253   int jresult ;
93254   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93255   unsigned int *arg2 = 0 ;
93256   unsigned int temp2 ;
93257   int result;
93258
93259   arg1 = (std::vector< unsigned int > *)jarg1;
93260   temp2 = (unsigned int)jarg2;
93261   arg2 = &temp2;
93262   {
93263     try {
93264       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
93265     } catch (std::out_of_range& e) {
93266       {
93267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93268       };
93269     } catch (std::exception& e) {
93270       {
93271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93272       };
93273     } catch (Dali::DaliException e) {
93274       {
93275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93276       };
93277     } catch (...) {
93278       {
93279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93280       };
93281     }
93282   }
93283
93284   jresult = result;
93285   return jresult;
93286 }
93287
93288
93289 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
93290   int jresult ;
93291   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93292   unsigned int *arg2 = 0 ;
93293   unsigned int temp2 ;
93294   int result;
93295
93296   arg1 = (std::vector< unsigned int > *)jarg1;
93297   temp2 = (unsigned int)jarg2;
93298   arg2 = &temp2;
93299   {
93300     try {
93301       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
93302     } catch (std::out_of_range& e) {
93303       {
93304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93305       };
93306     } catch (std::exception& e) {
93307       {
93308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93309       };
93310     } catch (Dali::DaliException e) {
93311       {
93312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93313       };
93314     } catch (...) {
93315       {
93316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93317       };
93318     }
93319   }
93320
93321   jresult = result;
93322   return jresult;
93323 }
93324
93325
93326 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
93327   unsigned int jresult ;
93328   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93329   unsigned int *arg2 = 0 ;
93330   unsigned int temp2 ;
93331   bool result;
93332
93333   arg1 = (std::vector< unsigned int > *)jarg1;
93334   temp2 = (unsigned int)jarg2;
93335   arg2 = &temp2;
93336   {
93337     try {
93338       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
93339     } catch (std::out_of_range& e) {
93340       {
93341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93342       };
93343     } catch (std::exception& e) {
93344       {
93345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93346       };
93347     } catch (Dali::DaliException e) {
93348       {
93349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93350       };
93351     } catch (...) {
93352       {
93353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93354       };
93355     }
93356   }
93357
93358   jresult = result;
93359   return jresult;
93360 }
93361
93362
93363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
93364   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93365
93366   arg1 = (std::vector< unsigned int > *)jarg1;
93367   {
93368     try {
93369       delete arg1;
93370     } catch (std::out_of_range& e) {
93371       {
93372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93373       };
93374     } catch (std::exception& e) {
93375       {
93376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93377       };
93378     } catch (Dali::DaliException e) {
93379       {
93380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93381       };
93382     } catch (...) {
93383       {
93384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93385       };
93386     }
93387   }
93388
93389 }
93390
93391
93392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
93393   void * jresult ;
93394   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93395
93396   {
93397     try {
93398       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
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 = (void *)result;
93419   return jresult;
93420 }
93421
93422
93423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
93424   void * jresult ;
93425   unsigned int arg1 ;
93426   Dali::Actor arg2 ;
93427   Dali::Actor *argp2 ;
93428   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93429
93430   arg1 = (unsigned int)jarg1;
93431   argp2 = (Dali::Actor *)jarg2;
93432   if (!argp2) {
93433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
93434     return 0;
93435   }
93436   arg2 = *argp2;
93437   {
93438     try {
93439       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
93440     } catch (std::out_of_range& e) {
93441       {
93442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93443       };
93444     } catch (std::exception& e) {
93445       {
93446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93447       };
93448     } catch (Dali::DaliException e) {
93449       {
93450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93451       };
93452     } catch (...) {
93453       {
93454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93455       };
93456     }
93457   }
93458
93459   jresult = (void *)result;
93460   return jresult;
93461 }
93462
93463
93464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
93465   void * jresult ;
93466   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
93467   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93468
93469   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93470   if (!arg1) {
93471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93472     return 0;
93473   }
93474   {
93475     try {
93476       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
93477     } catch (std::out_of_range& e) {
93478       {
93479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93480       };
93481     } catch (std::exception& e) {
93482       {
93483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93484       };
93485     } catch (Dali::DaliException e) {
93486       {
93487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93488       };
93489     } catch (...) {
93490       {
93491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93492       };
93493     }
93494   }
93495
93496   jresult = (void *)result;
93497   return jresult;
93498 }
93499
93500
93501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
93502   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93503   unsigned int arg2 ;
93504
93505   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93506   arg2 = (unsigned int)jarg2;
93507   if (arg1) (arg1)->first = arg2;
93508 }
93509
93510
93511 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
93512   unsigned int jresult ;
93513   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93514   unsigned int result;
93515
93516   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93517   result = (unsigned int) ((arg1)->first);
93518   jresult = result;
93519   return jresult;
93520 }
93521
93522
93523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
93524   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93525   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
93526
93527   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93528   arg2 = (Dali::Actor *)jarg2;
93529   if (arg1) (arg1)->second = *arg2;
93530 }
93531
93532
93533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
93534   void * jresult ;
93535   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93536   Dali::Actor *result = 0 ;
93537
93538   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93539   result = (Dali::Actor *)& ((arg1)->second);
93540   jresult = (void *)result;
93541   return jresult;
93542 }
93543
93544
93545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
93546   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93547
93548   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93549   {
93550     try {
93551       delete arg1;
93552     } catch (std::out_of_range& e) {
93553       {
93554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93555       };
93556     } catch (std::exception& e) {
93557       {
93558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93559       };
93560     } catch (Dali::DaliException e) {
93561       {
93562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93563       };
93564     } catch (...) {
93565       {
93566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93567       };
93568     }
93569   }
93570
93571 }
93572
93573
93574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
93575   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93576
93577   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93578   {
93579     try {
93580       (arg1)->clear();
93581     } catch (std::out_of_range& e) {
93582       {
93583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93584       };
93585     } catch (std::exception& e) {
93586       {
93587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93588       };
93589     } catch (Dali::DaliException e) {
93590       {
93591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93592       };
93593     } catch (...) {
93594       {
93595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93596       };
93597     }
93598   }
93599
93600 }
93601
93602
93603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
93604   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93605   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
93606
93607   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93608   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
93609   if (!arg2) {
93610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93611     return ;
93612   }
93613   {
93614     try {
93615       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
93616     } catch (std::out_of_range& e) {
93617       {
93618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93619       };
93620     } catch (std::exception& e) {
93621       {
93622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93623       };
93624     } catch (Dali::DaliException e) {
93625       {
93626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93627       };
93628     } catch (...) {
93629       {
93630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93631       };
93632     }
93633   }
93634
93635 }
93636
93637
93638 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
93639   unsigned long jresult ;
93640   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93641   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
93642
93643   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93644   {
93645     try {
93646       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
93647     } catch (std::out_of_range& e) {
93648       {
93649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93650       };
93651     } catch (std::exception& e) {
93652       {
93653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93654       };
93655     } catch (Dali::DaliException e) {
93656       {
93657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93658       };
93659     } catch (...) {
93660       {
93661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93662       };
93663     }
93664   }
93665
93666   jresult = (unsigned long)result;
93667   return jresult;
93668 }
93669
93670
93671 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
93672   unsigned long jresult ;
93673   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93674   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
93675
93676   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93677   {
93678     try {
93679       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
93680     } catch (std::out_of_range& e) {
93681       {
93682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93683       };
93684     } catch (std::exception& e) {
93685       {
93686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93687       };
93688     } catch (Dali::DaliException e) {
93689       {
93690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93691       };
93692     } catch (...) {
93693       {
93694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93695       };
93696     }
93697   }
93698
93699   jresult = (unsigned long)result;
93700   return jresult;
93701 }
93702
93703
93704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
93705   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93706   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
93707
93708   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93709   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
93710   {
93711     try {
93712       (arg1)->reserve(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 void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
93736   void * jresult ;
93737   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93738
93739   {
93740     try {
93741       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
93742     } catch (std::out_of_range& e) {
93743       {
93744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93745       };
93746     } catch (std::exception& e) {
93747       {
93748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93749       };
93750     } catch (Dali::DaliException e) {
93751       {
93752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93753       };
93754     } catch (...) {
93755       {
93756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93757       };
93758     }
93759   }
93760
93761   jresult = (void *)result;
93762   return jresult;
93763 }
93764
93765
93766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
93767   void * jresult ;
93768   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
93769   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93770
93771   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93772   if (!arg1) {
93773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93774     return 0;
93775   }
93776   {
93777     try {
93778       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);
93779     } catch (std::out_of_range& e) {
93780       {
93781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93782       };
93783     } catch (std::exception& e) {
93784       {
93785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93786       };
93787     } catch (Dali::DaliException e) {
93788       {
93789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93790       };
93791     } catch (...) {
93792       {
93793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93794       };
93795     }
93796   }
93797
93798   jresult = (void *)result;
93799   return jresult;
93800 }
93801
93802
93803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
93804   void * jresult ;
93805   int arg1 ;
93806   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93807
93808   arg1 = (int)jarg1;
93809   {
93810     try {
93811       try {
93812         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);
93813       }
93814       catch(std::out_of_range &_e) {
93815         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93816         return 0;
93817       }
93818
93819     } catch (std::out_of_range& e) {
93820       {
93821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93822       };
93823     } catch (std::exception& e) {
93824       {
93825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93826       };
93827     } catch (Dali::DaliException e) {
93828       {
93829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93830       };
93831     } catch (...) {
93832       {
93833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93834       };
93835     }
93836   }
93837
93838   jresult = (void *)result;
93839   return jresult;
93840 }
93841
93842
93843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
93844   void * jresult ;
93845   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93846   int arg2 ;
93847   std::pair< unsigned int,Dali::Actor > result;
93848
93849   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93850   arg2 = (int)jarg2;
93851   {
93852     try {
93853       try {
93854         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
93855       }
93856       catch(std::out_of_range &_e) {
93857         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93858         return 0;
93859       }
93860
93861     } catch (std::out_of_range& e) {
93862       {
93863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93864       };
93865     } catch (std::exception& e) {
93866       {
93867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93868       };
93869     } catch (Dali::DaliException e) {
93870       {
93871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93872       };
93873     } catch (...) {
93874       {
93875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93876       };
93877     }
93878   }
93879
93880   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
93881   return jresult;
93882 }
93883
93884
93885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
93886   void * jresult ;
93887   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93888   int arg2 ;
93889   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93890
93891   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93892   arg2 = (int)jarg2;
93893   {
93894     try {
93895       try {
93896         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
93897       }
93898       catch(std::out_of_range &_e) {
93899         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93900         return 0;
93901       }
93902
93903     } catch (std::out_of_range& e) {
93904       {
93905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93906       };
93907     } catch (std::exception& e) {
93908       {
93909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93910       };
93911     } catch (Dali::DaliException e) {
93912       {
93913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93914       };
93915     } catch (...) {
93916       {
93917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93918       };
93919     }
93920   }
93921
93922   jresult = (void *)result;
93923   return jresult;
93924 }
93925
93926
93927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
93928   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93929   int arg2 ;
93930   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
93931
93932   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93933   arg2 = (int)jarg2;
93934   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
93935   if (!arg3) {
93936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93937     return ;
93938   }
93939   {
93940     try {
93941       try {
93942         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);
93943       }
93944       catch(std::out_of_range &_e) {
93945         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93946         return ;
93947       }
93948
93949     } catch (std::out_of_range& e) {
93950       {
93951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93952       };
93953     } catch (std::exception& e) {
93954       {
93955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93956       };
93957     } catch (Dali::DaliException e) {
93958       {
93959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93960       };
93961     } catch (...) {
93962       {
93963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93964       };
93965     }
93966   }
93967
93968 }
93969
93970
93971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
93972   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93973   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
93974
93975   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93976   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
93977   if (!arg2) {
93978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93979     return ;
93980   }
93981   {
93982     try {
93983       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);
93984     } catch (std::out_of_range& e) {
93985       {
93986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93987       };
93988     } catch (std::exception& e) {
93989       {
93990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93991       };
93992     } catch (Dali::DaliException e) {
93993       {
93994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93995       };
93996     } catch (...) {
93997       {
93998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93999       };
94000     }
94001   }
94002
94003 }
94004
94005
94006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
94007   void * jresult ;
94008   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94009   int arg2 ;
94010   int arg3 ;
94011   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94012
94013   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94014   arg2 = (int)jarg2;
94015   arg3 = (int)jarg3;
94016   {
94017     try {
94018       try {
94019         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);
94020       }
94021       catch(std::out_of_range &_e) {
94022         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94023         return 0;
94024       }
94025       catch(std::invalid_argument &_e) {
94026         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94027         return 0;
94028       }
94029
94030     } catch (std::out_of_range& e) {
94031       {
94032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94033       };
94034     } catch (std::exception& e) {
94035       {
94036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94037       };
94038     } catch (Dali::DaliException e) {
94039       {
94040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94041       };
94042     } catch (...) {
94043       {
94044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94045       };
94046     }
94047   }
94048
94049   jresult = (void *)result;
94050   return jresult;
94051 }
94052
94053
94054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
94055   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94056   int arg2 ;
94057   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
94058
94059   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94060   arg2 = (int)jarg2;
94061   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
94062   if (!arg3) {
94063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94064     return ;
94065   }
94066   {
94067     try {
94068       try {
94069         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);
94070       }
94071       catch(std::out_of_range &_e) {
94072         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94073         return ;
94074       }
94075
94076     } catch (std::out_of_range& e) {
94077       {
94078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94079       };
94080     } catch (std::exception& e) {
94081       {
94082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94083       };
94084     } catch (Dali::DaliException e) {
94085       {
94086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94087       };
94088     } catch (...) {
94089       {
94090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94091       };
94092     }
94093   }
94094
94095 }
94096
94097
94098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
94099   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94100   int arg2 ;
94101   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94102
94103   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94104   arg2 = (int)jarg2;
94105   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94106   if (!arg3) {
94107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94108     return ;
94109   }
94110   {
94111     try {
94112       try {
94113         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);
94114       }
94115       catch(std::out_of_range &_e) {
94116         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94117         return ;
94118       }
94119
94120     } catch (std::out_of_range& e) {
94121       {
94122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94123       };
94124     } catch (std::exception& e) {
94125       {
94126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94127       };
94128     } catch (Dali::DaliException e) {
94129       {
94130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94131       };
94132     } catch (...) {
94133       {
94134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94135       };
94136     }
94137   }
94138
94139 }
94140
94141
94142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
94143   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94144   int arg2 ;
94145
94146   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94147   arg2 = (int)jarg2;
94148   {
94149     try {
94150       try {
94151         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
94152       }
94153       catch(std::out_of_range &_e) {
94154         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94155         return ;
94156       }
94157
94158     } catch (std::out_of_range& e) {
94159       {
94160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94161       };
94162     } catch (std::exception& e) {
94163       {
94164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94165       };
94166     } catch (Dali::DaliException e) {
94167       {
94168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94169       };
94170     } catch (...) {
94171       {
94172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94173       };
94174     }
94175   }
94176
94177 }
94178
94179
94180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
94181   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94182   int arg2 ;
94183   int arg3 ;
94184
94185   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94186   arg2 = (int)jarg2;
94187   arg3 = (int)jarg3;
94188   {
94189     try {
94190       try {
94191         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
94192       }
94193       catch(std::out_of_range &_e) {
94194         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94195         return ;
94196       }
94197       catch(std::invalid_argument &_e) {
94198         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94199         return ;
94200       }
94201
94202     } catch (std::out_of_range& e) {
94203       {
94204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94205       };
94206     } catch (std::exception& e) {
94207       {
94208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94209       };
94210     } catch (Dali::DaliException e) {
94211       {
94212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94213       };
94214     } catch (...) {
94215       {
94216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94217       };
94218     }
94219   }
94220
94221 }
94222
94223
94224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
94225   void * jresult ;
94226   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
94227   int arg2 ;
94228   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94229
94230   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94231   if (!arg1) {
94232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94233     return 0;
94234   }
94235   arg2 = (int)jarg2;
94236   {
94237     try {
94238       try {
94239         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);
94240       }
94241       catch(std::out_of_range &_e) {
94242         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94243         return 0;
94244       }
94245
94246     } catch (std::out_of_range& e) {
94247       {
94248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94249       };
94250     } catch (std::exception& e) {
94251       {
94252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94253       };
94254     } catch (Dali::DaliException e) {
94255       {
94256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94257       };
94258     } catch (...) {
94259       {
94260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94261       };
94262     }
94263   }
94264
94265   jresult = (void *)result;
94266   return jresult;
94267 }
94268
94269
94270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
94271   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94272
94273   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94274   {
94275     try {
94276       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
94277     } catch (std::out_of_range& e) {
94278       {
94279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94280       };
94281     } catch (std::exception& e) {
94282       {
94283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94284       };
94285     } catch (Dali::DaliException e) {
94286       {
94287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94288       };
94289     } catch (...) {
94290       {
94291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94292       };
94293     }
94294   }
94295
94296 }
94297
94298
94299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
94300   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94301   int arg2 ;
94302   int arg3 ;
94303
94304   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94305   arg2 = (int)jarg2;
94306   arg3 = (int)jarg3;
94307   {
94308     try {
94309       try {
94310         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
94311       }
94312       catch(std::out_of_range &_e) {
94313         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94314         return ;
94315       }
94316       catch(std::invalid_argument &_e) {
94317         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94318         return ;
94319       }
94320
94321     } catch (std::out_of_range& e) {
94322       {
94323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94324       };
94325     } catch (std::exception& e) {
94326       {
94327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94328       };
94329     } catch (Dali::DaliException e) {
94330       {
94331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94332       };
94333     } catch (...) {
94334       {
94335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94336       };
94337     }
94338   }
94339
94340 }
94341
94342
94343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
94344   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94345   int arg2 ;
94346   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94347
94348   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94349   arg2 = (int)jarg2;
94350   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94351   if (!arg3) {
94352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94353     return ;
94354   }
94355   {
94356     try {
94357       try {
94358         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);
94359       }
94360       catch(std::out_of_range &_e) {
94361         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94362         return ;
94363       }
94364
94365     } catch (std::out_of_range& e) {
94366       {
94367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94368       };
94369     } catch (std::exception& e) {
94370       {
94371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94372       };
94373     } catch (Dali::DaliException e) {
94374       {
94375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94376       };
94377     } catch (...) {
94378       {
94379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94380       };
94381     }
94382   }
94383
94384 }
94385
94386
94387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
94388   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94389
94390   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94391   {
94392     try {
94393       delete arg1;
94394     } catch (std::out_of_range& e) {
94395       {
94396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94397       };
94398     } catch (std::exception& e) {
94399       {
94400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94401       };
94402     } catch (Dali::DaliException e) {
94403       {
94404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94405       };
94406     } catch (...) {
94407       {
94408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94409       };
94410     }
94411   }
94412
94413 }
94414
94415
94416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
94417   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94418
94419   arg1 = (std::vector< Dali::Actor > *)jarg1;
94420   {
94421     try {
94422       (arg1)->clear();
94423     } catch (std::out_of_range& e) {
94424       {
94425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94426       };
94427     } catch (std::exception& e) {
94428       {
94429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94430       };
94431     } catch (Dali::DaliException e) {
94432       {
94433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94434       };
94435     } catch (...) {
94436       {
94437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94438       };
94439     }
94440   }
94441
94442 }
94443
94444
94445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
94446   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94447   Dali::Actor *arg2 = 0 ;
94448
94449   arg1 = (std::vector< Dali::Actor > *)jarg1;
94450   arg2 = (Dali::Actor *)jarg2;
94451   if (!arg2) {
94452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94453     return ;
94454   }
94455   {
94456     try {
94457       (arg1)->push_back((Dali::Actor const &)*arg2);
94458     } catch (std::out_of_range& e) {
94459       {
94460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94461       };
94462     } catch (std::exception& e) {
94463       {
94464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94465       };
94466     } catch (Dali::DaliException e) {
94467       {
94468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94469       };
94470     } catch (...) {
94471       {
94472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94473       };
94474     }
94475   }
94476
94477 }
94478
94479
94480 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
94481   unsigned long jresult ;
94482   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94483   std::vector< Dali::Actor >::size_type result;
94484
94485   arg1 = (std::vector< Dali::Actor > *)jarg1;
94486   {
94487     try {
94488       result = ((std::vector< Dali::Actor > const *)arg1)->size();
94489     } catch (std::out_of_range& e) {
94490       {
94491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94492       };
94493     } catch (std::exception& e) {
94494       {
94495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94496       };
94497     } catch (Dali::DaliException e) {
94498       {
94499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94500       };
94501     } catch (...) {
94502       {
94503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94504       };
94505     }
94506   }
94507
94508   jresult = (unsigned long)result;
94509   return jresult;
94510 }
94511
94512
94513 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
94514   unsigned long jresult ;
94515   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94516   std::vector< Dali::Actor >::size_type result;
94517
94518   arg1 = (std::vector< Dali::Actor > *)jarg1;
94519   {
94520     try {
94521       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
94522     } catch (std::out_of_range& e) {
94523       {
94524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94525       };
94526     } catch (std::exception& e) {
94527       {
94528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94529       };
94530     } catch (Dali::DaliException e) {
94531       {
94532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94533       };
94534     } catch (...) {
94535       {
94536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94537       };
94538     }
94539   }
94540
94541   jresult = (unsigned long)result;
94542   return jresult;
94543 }
94544
94545
94546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
94547   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94548   std::vector< Dali::Actor >::size_type arg2 ;
94549
94550   arg1 = (std::vector< Dali::Actor > *)jarg1;
94551   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
94552   {
94553     try {
94554       (arg1)->reserve(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 void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
94578   void * jresult ;
94579   std::vector< Dali::Actor > *result = 0 ;
94580
94581   {
94582     try {
94583       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
94584     } catch (std::out_of_range& e) {
94585       {
94586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94587       };
94588     } catch (std::exception& e) {
94589       {
94590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94591       };
94592     } catch (Dali::DaliException e) {
94593       {
94594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94595       };
94596     } catch (...) {
94597       {
94598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94599       };
94600     }
94601   }
94602
94603   jresult = (void *)result;
94604   return jresult;
94605 }
94606
94607
94608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
94609   void * jresult ;
94610   std::vector< Dali::Actor > *arg1 = 0 ;
94611   std::vector< Dali::Actor > *result = 0 ;
94612
94613   arg1 = (std::vector< Dali::Actor > *)jarg1;
94614   if (!arg1) {
94615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94616     return 0;
94617   }
94618   {
94619     try {
94620       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
94621     } catch (std::out_of_range& e) {
94622       {
94623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94624       };
94625     } catch (std::exception& e) {
94626       {
94627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94628       };
94629     } catch (Dali::DaliException e) {
94630       {
94631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94632       };
94633     } catch (...) {
94634       {
94635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94636       };
94637     }
94638   }
94639
94640   jresult = (void *)result;
94641   return jresult;
94642 }
94643
94644
94645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
94646   void * jresult ;
94647   int arg1 ;
94648   std::vector< Dali::Actor > *result = 0 ;
94649
94650   arg1 = (int)jarg1;
94651   {
94652     try {
94653       try {
94654         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
94655       }
94656       catch(std::out_of_range &_e) {
94657         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94658         return 0;
94659       }
94660
94661     } catch (std::out_of_range& e) {
94662       {
94663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94664       };
94665     } catch (std::exception& e) {
94666       {
94667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94668       };
94669     } catch (Dali::DaliException e) {
94670       {
94671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94672       };
94673     } catch (...) {
94674       {
94675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94676       };
94677     }
94678   }
94679
94680   jresult = (void *)result;
94681   return jresult;
94682 }
94683
94684
94685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
94686   void * jresult ;
94687   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94688   int arg2 ;
94689   Dali::Actor result;
94690
94691   arg1 = (std::vector< Dali::Actor > *)jarg1;
94692   arg2 = (int)jarg2;
94693   {
94694     try {
94695       try {
94696         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
94697       }
94698       catch(std::out_of_range &_e) {
94699         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94700         return 0;
94701       }
94702
94703     } catch (std::out_of_range& e) {
94704       {
94705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94706       };
94707     } catch (std::exception& e) {
94708       {
94709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94710       };
94711     } catch (Dali::DaliException e) {
94712       {
94713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94714       };
94715     } catch (...) {
94716       {
94717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94718       };
94719     }
94720   }
94721
94722   jresult = new Dali::Actor((const Dali::Actor &)result);
94723   return jresult;
94724 }
94725
94726
94727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
94728   void * jresult ;
94729   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94730   int arg2 ;
94731   Dali::Actor *result = 0 ;
94732
94733   arg1 = (std::vector< Dali::Actor > *)jarg1;
94734   arg2 = (int)jarg2;
94735   {
94736     try {
94737       try {
94738         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
94739       }
94740       catch(std::out_of_range &_e) {
94741         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94742         return 0;
94743       }
94744
94745     } catch (std::out_of_range& e) {
94746       {
94747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94748       };
94749     } catch (std::exception& e) {
94750       {
94751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94752       };
94753     } catch (Dali::DaliException e) {
94754       {
94755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94756       };
94757     } catch (...) {
94758       {
94759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94760       };
94761     }
94762   }
94763
94764   jresult = (void *)result;
94765   return jresult;
94766 }
94767
94768
94769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
94770   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94771   int arg2 ;
94772   Dali::Actor *arg3 = 0 ;
94773
94774   arg1 = (std::vector< Dali::Actor > *)jarg1;
94775   arg2 = (int)jarg2;
94776   arg3 = (Dali::Actor *)jarg3;
94777   if (!arg3) {
94778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94779     return ;
94780   }
94781   {
94782     try {
94783       try {
94784         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
94785       }
94786       catch(std::out_of_range &_e) {
94787         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94788         return ;
94789       }
94790
94791     } catch (std::out_of_range& e) {
94792       {
94793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94794       };
94795     } catch (std::exception& e) {
94796       {
94797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94798       };
94799     } catch (Dali::DaliException e) {
94800       {
94801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94802       };
94803     } catch (...) {
94804       {
94805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94806       };
94807     }
94808   }
94809
94810 }
94811
94812
94813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
94814   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94815   std::vector< Dali::Actor > *arg2 = 0 ;
94816
94817   arg1 = (std::vector< Dali::Actor > *)jarg1;
94818   arg2 = (std::vector< Dali::Actor > *)jarg2;
94819   if (!arg2) {
94820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94821     return ;
94822   }
94823   {
94824     try {
94825       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
94826     } catch (std::out_of_range& e) {
94827       {
94828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94829       };
94830     } catch (std::exception& e) {
94831       {
94832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94833       };
94834     } catch (Dali::DaliException e) {
94835       {
94836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94837       };
94838     } catch (...) {
94839       {
94840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94841       };
94842     }
94843   }
94844
94845 }
94846
94847
94848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
94849   void * jresult ;
94850   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94851   int arg2 ;
94852   int arg3 ;
94853   std::vector< Dali::Actor > *result = 0 ;
94854
94855   arg1 = (std::vector< Dali::Actor > *)jarg1;
94856   arg2 = (int)jarg2;
94857   arg3 = (int)jarg3;
94858   {
94859     try {
94860       try {
94861         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
94862       }
94863       catch(std::out_of_range &_e) {
94864         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94865         return 0;
94866       }
94867       catch(std::invalid_argument &_e) {
94868         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94869         return 0;
94870       }
94871
94872     } catch (std::out_of_range& e) {
94873       {
94874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94875       };
94876     } catch (std::exception& e) {
94877       {
94878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94879       };
94880     } catch (Dali::DaliException e) {
94881       {
94882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94883       };
94884     } catch (...) {
94885       {
94886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94887       };
94888     }
94889   }
94890
94891   jresult = (void *)result;
94892   return jresult;
94893 }
94894
94895
94896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
94897   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94898   int arg2 ;
94899   Dali::Actor *arg3 = 0 ;
94900
94901   arg1 = (std::vector< Dali::Actor > *)jarg1;
94902   arg2 = (int)jarg2;
94903   arg3 = (Dali::Actor *)jarg3;
94904   if (!arg3) {
94905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94906     return ;
94907   }
94908   {
94909     try {
94910       try {
94911         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
94912       }
94913       catch(std::out_of_range &_e) {
94914         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94915         return ;
94916       }
94917
94918     } catch (std::out_of_range& e) {
94919       {
94920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94921       };
94922     } catch (std::exception& e) {
94923       {
94924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94925       };
94926     } catch (Dali::DaliException e) {
94927       {
94928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94929       };
94930     } catch (...) {
94931       {
94932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94933       };
94934     }
94935   }
94936
94937 }
94938
94939
94940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
94941   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94942   int arg2 ;
94943   std::vector< Dali::Actor > *arg3 = 0 ;
94944
94945   arg1 = (std::vector< Dali::Actor > *)jarg1;
94946   arg2 = (int)jarg2;
94947   arg3 = (std::vector< Dali::Actor > *)jarg3;
94948   if (!arg3) {
94949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94950     return ;
94951   }
94952   {
94953     try {
94954       try {
94955         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
94956       }
94957       catch(std::out_of_range &_e) {
94958         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94959         return ;
94960       }
94961
94962     } catch (std::out_of_range& e) {
94963       {
94964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94965       };
94966     } catch (std::exception& e) {
94967       {
94968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94969       };
94970     } catch (Dali::DaliException e) {
94971       {
94972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94973       };
94974     } catch (...) {
94975       {
94976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94977       };
94978     }
94979   }
94980
94981 }
94982
94983
94984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
94985   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94986   int arg2 ;
94987
94988   arg1 = (std::vector< Dali::Actor > *)jarg1;
94989   arg2 = (int)jarg2;
94990   {
94991     try {
94992       try {
94993         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
94994       }
94995       catch(std::out_of_range &_e) {
94996         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94997         return ;
94998       }
94999
95000     } catch (std::out_of_range& e) {
95001       {
95002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95003       };
95004     } catch (std::exception& e) {
95005       {
95006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95007       };
95008     } catch (Dali::DaliException e) {
95009       {
95010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95011       };
95012     } catch (...) {
95013       {
95014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95015       };
95016     }
95017   }
95018
95019 }
95020
95021
95022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
95023   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95024   int arg2 ;
95025   int arg3 ;
95026
95027   arg1 = (std::vector< Dali::Actor > *)jarg1;
95028   arg2 = (int)jarg2;
95029   arg3 = (int)jarg3;
95030   {
95031     try {
95032       try {
95033         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
95034       }
95035       catch(std::out_of_range &_e) {
95036         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95037         return ;
95038       }
95039       catch(std::invalid_argument &_e) {
95040         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95041         return ;
95042       }
95043
95044     } catch (std::out_of_range& e) {
95045       {
95046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95047       };
95048     } catch (std::exception& e) {
95049       {
95050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95051       };
95052     } catch (Dali::DaliException e) {
95053       {
95054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95055       };
95056     } catch (...) {
95057       {
95058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95059       };
95060     }
95061   }
95062
95063 }
95064
95065
95066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
95067   void * jresult ;
95068   Dali::Actor *arg1 = 0 ;
95069   int arg2 ;
95070   std::vector< Dali::Actor > *result = 0 ;
95071
95072   arg1 = (Dali::Actor *)jarg1;
95073   if (!arg1) {
95074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95075     return 0;
95076   }
95077   arg2 = (int)jarg2;
95078   {
95079     try {
95080       try {
95081         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
95082       }
95083       catch(std::out_of_range &_e) {
95084         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95085         return 0;
95086       }
95087
95088     } catch (std::out_of_range& e) {
95089       {
95090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95091       };
95092     } catch (std::exception& e) {
95093       {
95094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95095       };
95096     } catch (Dali::DaliException e) {
95097       {
95098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95099       };
95100     } catch (...) {
95101       {
95102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95103       };
95104     }
95105   }
95106
95107   jresult = (void *)result;
95108   return jresult;
95109 }
95110
95111
95112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
95113   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95114
95115   arg1 = (std::vector< Dali::Actor > *)jarg1;
95116   {
95117     try {
95118       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
95119     } catch (std::out_of_range& e) {
95120       {
95121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95122       };
95123     } catch (std::exception& e) {
95124       {
95125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95126       };
95127     } catch (Dali::DaliException e) {
95128       {
95129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95130       };
95131     } catch (...) {
95132       {
95133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95134       };
95135     }
95136   }
95137
95138 }
95139
95140
95141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
95142   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95143   int arg2 ;
95144   int arg3 ;
95145
95146   arg1 = (std::vector< Dali::Actor > *)jarg1;
95147   arg2 = (int)jarg2;
95148   arg3 = (int)jarg3;
95149   {
95150     try {
95151       try {
95152         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
95153       }
95154       catch(std::out_of_range &_e) {
95155         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95156         return ;
95157       }
95158       catch(std::invalid_argument &_e) {
95159         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95160         return ;
95161       }
95162
95163     } catch (std::out_of_range& e) {
95164       {
95165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95166       };
95167     } catch (std::exception& e) {
95168       {
95169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95170       };
95171     } catch (Dali::DaliException e) {
95172       {
95173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95174       };
95175     } catch (...) {
95176       {
95177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95178       };
95179     }
95180   }
95181
95182 }
95183
95184
95185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
95186   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95187   int arg2 ;
95188   std::vector< Dali::Actor > *arg3 = 0 ;
95189
95190   arg1 = (std::vector< Dali::Actor > *)jarg1;
95191   arg2 = (int)jarg2;
95192   arg3 = (std::vector< Dali::Actor > *)jarg3;
95193   if (!arg3) {
95194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95195     return ;
95196   }
95197   {
95198     try {
95199       try {
95200         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
95201       }
95202       catch(std::out_of_range &_e) {
95203         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95204         return ;
95205       }
95206
95207     } catch (std::out_of_range& e) {
95208       {
95209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95210       };
95211     } catch (std::exception& e) {
95212       {
95213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95214       };
95215     } catch (Dali::DaliException e) {
95216       {
95217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95218       };
95219     } catch (...) {
95220       {
95221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95222       };
95223     }
95224   }
95225
95226 }
95227
95228
95229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
95230   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95231
95232   arg1 = (std::vector< Dali::Actor > *)jarg1;
95233   {
95234     try {
95235       delete arg1;
95236     } catch (std::out_of_range& e) {
95237       {
95238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95239       };
95240     } catch (std::exception& e) {
95241       {
95242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95243       };
95244     } catch (Dali::DaliException e) {
95245       {
95246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95247       };
95248     } catch (...) {
95249       {
95250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95251       };
95252     }
95253   }
95254
95255 }
95256
95257
95258 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
95259   unsigned int jresult ;
95260   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95261   bool result;
95262
95263   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95264   {
95265     try {
95266       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95267     } catch (std::out_of_range& e) {
95268       {
95269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95270       };
95271     } catch (std::exception& e) {
95272       {
95273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95274       };
95275     } catch (Dali::DaliException e) {
95276       {
95277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95278       };
95279     } catch (...) {
95280       {
95281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95282       };
95283     }
95284   }
95285
95286   jresult = result;
95287   return jresult;
95288 }
95289
95290
95291 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
95292   unsigned long jresult ;
95293   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95294   std::size_t result;
95295
95296   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95297   {
95298     try {
95299       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95300     } catch (std::out_of_range& e) {
95301       {
95302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95303       };
95304     } catch (std::exception& e) {
95305       {
95306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95307       };
95308     } catch (Dali::DaliException e) {
95309       {
95310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95311       };
95312     } catch (...) {
95313       {
95314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95315       };
95316     }
95317   }
95318
95319   jresult = (unsigned long)result;
95320   return jresult;
95321 }
95322
95323
95324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
95325   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95326   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95327
95328   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95329   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95330   {
95331     try {
95332       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
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 void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
95356   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95357   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95358
95359   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95360   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95361   {
95362     try {
95363       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
95364     } catch (std::out_of_range& e) {
95365       {
95366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95367       };
95368     } catch (std::exception& e) {
95369       {
95370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95371       };
95372     } catch (Dali::DaliException e) {
95373       {
95374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95375       };
95376     } catch (...) {
95377       {
95378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95379       };
95380     }
95381   }
95382
95383 }
95384
95385
95386 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
95387   unsigned int jresult ;
95388   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95389   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
95390   bool result;
95391
95392   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95393   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
95394   if (!arg2) {
95395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
95396     return 0;
95397   }
95398   {
95399     try {
95400       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
95401     } catch (std::out_of_range& e) {
95402       {
95403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95404       };
95405     } catch (std::exception& e) {
95406       {
95407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95408       };
95409     } catch (Dali::DaliException e) {
95410       {
95411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95412       };
95413     } catch (...) {
95414       {
95415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95416       };
95417     }
95418   }
95419
95420   jresult = result;
95421   return jresult;
95422 }
95423
95424
95425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
95426   void * jresult ;
95427   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
95428
95429   {
95430     try {
95431       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
95432     } catch (std::out_of_range& e) {
95433       {
95434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95435       };
95436     } catch (std::exception& e) {
95437       {
95438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95439       };
95440     } catch (Dali::DaliException e) {
95441       {
95442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95443       };
95444     } catch (...) {
95445       {
95446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95447       };
95448     }
95449   }
95450
95451   jresult = (void *)result;
95452   return jresult;
95453 }
95454
95455
95456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
95457   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95458
95459   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95460   {
95461     try {
95462       delete arg1;
95463     } catch (std::out_of_range& e) {
95464       {
95465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95466       };
95467     } catch (std::exception& e) {
95468       {
95469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95470       };
95471     } catch (Dali::DaliException e) {
95472       {
95473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95474       };
95475     } catch (...) {
95476       {
95477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95478       };
95479     }
95480   }
95481
95482 }
95483
95484
95485 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
95486   unsigned int jresult ;
95487   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95488   bool result;
95489
95490   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95491   {
95492     try {
95493       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);
95494     } catch (std::out_of_range& e) {
95495       {
95496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95497       };
95498     } catch (std::exception& e) {
95499       {
95500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95501       };
95502     } catch (Dali::DaliException e) {
95503       {
95504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95505       };
95506     } catch (...) {
95507       {
95508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95509       };
95510     }
95511   }
95512
95513   jresult = result;
95514   return jresult;
95515 }
95516
95517
95518 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
95519   unsigned long jresult ;
95520   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95521   std::size_t result;
95522
95523   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95524   {
95525     try {
95526       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);
95527     } catch (std::out_of_range& e) {
95528       {
95529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95530       };
95531     } catch (std::exception& e) {
95532       {
95533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95534       };
95535     } catch (Dali::DaliException e) {
95536       {
95537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95538       };
95539     } catch (...) {
95540       {
95541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95542       };
95543     }
95544   }
95545
95546   jresult = (unsigned long)result;
95547   return jresult;
95548 }
95549
95550
95551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
95552   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95553   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
95554
95555   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95556   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
95557   {
95558     try {
95559       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
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 void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
95583   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95584   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
95585
95586   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95587   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
95588   {
95589     try {
95590       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
95591     } catch (std::out_of_range& e) {
95592       {
95593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95594       };
95595     } catch (std::exception& e) {
95596       {
95597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95598       };
95599     } catch (Dali::DaliException e) {
95600       {
95601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95602       };
95603     } catch (...) {
95604       {
95605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95606       };
95607     }
95608   }
95609
95610 }
95611
95612
95613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
95614   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95615   Dali::Actor arg2 ;
95616   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
95617   Dali::Actor *argp2 ;
95618
95619   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95620   argp2 = (Dali::Actor *)jarg2;
95621   if (!argp2) {
95622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95623     return ;
95624   }
95625   arg2 = *argp2;
95626   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
95627   {
95628     try {
95629       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
95630     } catch (std::out_of_range& e) {
95631       {
95632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95633       };
95634     } catch (std::exception& e) {
95635       {
95636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95637       };
95638     } catch (Dali::DaliException e) {
95639       {
95640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95641       };
95642     } catch (...) {
95643       {
95644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95645       };
95646     }
95647   }
95648
95649 }
95650
95651
95652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
95653   void * jresult ;
95654   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
95655
95656   {
95657     try {
95658       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
95659     } catch (std::out_of_range& e) {
95660       {
95661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95662       };
95663     } catch (std::exception& e) {
95664       {
95665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95666       };
95667     } catch (Dali::DaliException e) {
95668       {
95669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95670       };
95671     } catch (...) {
95672       {
95673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95674       };
95675     }
95676   }
95677
95678   jresult = (void *)result;
95679   return jresult;
95680 }
95681
95682
95683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
95684   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95685
95686   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95687   {
95688     try {
95689       delete arg1;
95690     } catch (std::out_of_range& e) {
95691       {
95692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95693       };
95694     } catch (std::exception& e) {
95695       {
95696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95697       };
95698     } catch (Dali::DaliException e) {
95699       {
95700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95701       };
95702     } catch (...) {
95703       {
95704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95705       };
95706     }
95707   }
95708
95709 }
95710
95711
95712 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
95713   unsigned int jresult ;
95714   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95715   bool result;
95716
95717   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95718   {
95719     try {
95720       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
95721     } catch (std::out_of_range& e) {
95722       {
95723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95724       };
95725     } catch (std::exception& e) {
95726       {
95727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95728       };
95729     } catch (Dali::DaliException e) {
95730       {
95731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95732       };
95733     } catch (...) {
95734       {
95735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95736       };
95737     }
95738   }
95739
95740   jresult = result;
95741   return jresult;
95742 }
95743
95744
95745 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
95746   unsigned long jresult ;
95747   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95748   std::size_t result;
95749
95750   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95751   {
95752     try {
95753       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
95754     } catch (std::out_of_range& e) {
95755       {
95756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95757       };
95758     } catch (std::exception& e) {
95759       {
95760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95761       };
95762     } catch (Dali::DaliException e) {
95763       {
95764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95765       };
95766     } catch (...) {
95767       {
95768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95769       };
95770     }
95771   }
95772
95773   jresult = (unsigned long)result;
95774   return jresult;
95775 }
95776
95777
95778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
95779   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95780   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
95781
95782   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95783   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
95784   {
95785     try {
95786       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
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 void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
95810   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95811   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
95812
95813   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95814   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
95815   {
95816     try {
95817       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
95818     } catch (std::out_of_range& e) {
95819       {
95820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95821       };
95822     } catch (std::exception& e) {
95823       {
95824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95825       };
95826     } catch (Dali::DaliException e) {
95827       {
95828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95829       };
95830     } catch (...) {
95831       {
95832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95833       };
95834     }
95835   }
95836
95837 }
95838
95839
95840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
95841   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95842   Dali::Actor arg2 ;
95843   Dali::Actor arg3 ;
95844   Dali::Actor *argp2 ;
95845   Dali::Actor *argp3 ;
95846
95847   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95848   argp2 = (Dali::Actor *)jarg2;
95849   if (!argp2) {
95850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95851     return ;
95852   }
95853   arg2 = *argp2;
95854   argp3 = (Dali::Actor *)jarg3;
95855   if (!argp3) {
95856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95857     return ;
95858   }
95859   arg3 = *argp3;
95860   {
95861     try {
95862       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
95863     } catch (std::out_of_range& e) {
95864       {
95865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95866       };
95867     } catch (std::exception& e) {
95868       {
95869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95870       };
95871     } catch (Dali::DaliException e) {
95872       {
95873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95874       };
95875     } catch (...) {
95876       {
95877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95878       };
95879     }
95880   }
95881
95882 }
95883
95884
95885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
95886   void * jresult ;
95887   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
95888
95889   {
95890     try {
95891       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
95892     } catch (std::out_of_range& e) {
95893       {
95894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95895       };
95896     } catch (std::exception& e) {
95897       {
95898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95899       };
95900     } catch (Dali::DaliException e) {
95901       {
95902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95903       };
95904     } catch (...) {
95905       {
95906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95907       };
95908     }
95909   }
95910
95911   jresult = (void *)result;
95912   return jresult;
95913 }
95914
95915
95916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
95917   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95918
95919   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95920   {
95921     try {
95922       delete arg1;
95923     } catch (std::out_of_range& e) {
95924       {
95925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95926       };
95927     } catch (std::exception& e) {
95928       {
95929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95930       };
95931     } catch (Dali::DaliException e) {
95932       {
95933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95934       };
95935     } catch (...) {
95936       {
95937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95938       };
95939     }
95940   }
95941
95942 }
95943
95944
95945 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
95946   unsigned int jresult ;
95947   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95948   bool result;
95949
95950   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95951   {
95952     try {
95953       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
95954     } catch (std::out_of_range& e) {
95955       {
95956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95957       };
95958     } catch (std::exception& e) {
95959       {
95960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95961       };
95962     } catch (Dali::DaliException e) {
95963       {
95964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95965       };
95966     } catch (...) {
95967       {
95968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95969       };
95970     }
95971   }
95972
95973   jresult = result;
95974   return jresult;
95975 }
95976
95977
95978 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
95979   unsigned long jresult ;
95980   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95981   std::size_t result;
95982
95983   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95984   {
95985     try {
95986       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
95987     } catch (std::out_of_range& e) {
95988       {
95989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95990       };
95991     } catch (std::exception& e) {
95992       {
95993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95994       };
95995     } catch (Dali::DaliException e) {
95996       {
95997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95998       };
95999     } catch (...) {
96000       {
96001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96002       };
96003     }
96004   }
96005
96006   jresult = (unsigned long)result;
96007   return jresult;
96008 }
96009
96010
96011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
96012   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96013   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
96014
96015   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96016   arg2 = (void (*)(Dali::Actor,bool))jarg2;
96017   {
96018     try {
96019       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
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 void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96043   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96044   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
96045
96046   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96047   arg2 = (void (*)(Dali::Actor,bool))jarg2;
96048   {
96049     try {
96050       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
96051     } catch (std::out_of_range& e) {
96052       {
96053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96054       };
96055     } catch (std::exception& e) {
96056       {
96057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96058       };
96059     } catch (Dali::DaliException e) {
96060       {
96061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96062       };
96063     } catch (...) {
96064       {
96065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96066       };
96067     }
96068   }
96069
96070 }
96071
96072
96073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
96074   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96075   Dali::Actor arg2 ;
96076   bool arg3 ;
96077   Dali::Actor *argp2 ;
96078
96079   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96080   argp2 = (Dali::Actor *)jarg2;
96081   if (!argp2) {
96082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96083     return ;
96084   }
96085   arg2 = *argp2;
96086   arg3 = jarg3 ? true : false;
96087   {
96088     try {
96089       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
96090     } catch (std::out_of_range& e) {
96091       {
96092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96093       };
96094     } catch (std::exception& e) {
96095       {
96096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96097       };
96098     } catch (Dali::DaliException e) {
96099       {
96100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96101       };
96102     } catch (...) {
96103       {
96104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96105       };
96106     }
96107   }
96108
96109 }
96110
96111
96112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
96113   void * jresult ;
96114   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
96115
96116   {
96117     try {
96118       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
96119     } catch (std::out_of_range& e) {
96120       {
96121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96122       };
96123     } catch (std::exception& e) {
96124       {
96125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96126       };
96127     } catch (Dali::DaliException e) {
96128       {
96129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96130       };
96131     } catch (...) {
96132       {
96133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96134       };
96135     }
96136   }
96137
96138   jresult = (void *)result;
96139   return jresult;
96140 }
96141
96142
96143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
96144   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96145
96146   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96147   {
96148     try {
96149       delete arg1;
96150     } catch (std::out_of_range& e) {
96151       {
96152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96153       };
96154     } catch (std::exception& e) {
96155       {
96156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96157       };
96158     } catch (Dali::DaliException e) {
96159       {
96160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96161       };
96162     } catch (...) {
96163       {
96164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96165       };
96166     }
96167   }
96168
96169 }
96170
96171
96172 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
96173   unsigned int jresult ;
96174   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96175   bool result;
96176
96177   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96178   {
96179     try {
96180       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);
96181     } catch (std::out_of_range& e) {
96182       {
96183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96184       };
96185     } catch (std::exception& e) {
96186       {
96187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96188       };
96189     } catch (Dali::DaliException e) {
96190       {
96191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96192       };
96193     } catch (...) {
96194       {
96195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96196       };
96197     }
96198   }
96199
96200   jresult = result;
96201   return jresult;
96202 }
96203
96204
96205 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
96206   unsigned long jresult ;
96207   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96208   std::size_t result;
96209
96210   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96211   {
96212     try {
96213       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);
96214     } catch (std::out_of_range& e) {
96215       {
96216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96217       };
96218     } catch (std::exception& e) {
96219       {
96220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96221       };
96222     } catch (Dali::DaliException e) {
96223       {
96224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96225       };
96226     } catch (...) {
96227       {
96228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96229       };
96230     }
96231   }
96232
96233   jresult = (unsigned long)result;
96234   return jresult;
96235 }
96236
96237
96238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
96239   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96240   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96241
96242   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96243   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96244   {
96245     try {
96246       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
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 void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96270   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96271   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96272
96273   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96274   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96275   {
96276     try {
96277       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
96278     } catch (std::out_of_range& e) {
96279       {
96280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96281       };
96282     } catch (std::exception& e) {
96283       {
96284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96285       };
96286     } catch (Dali::DaliException e) {
96287       {
96288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96289       };
96290     } catch (...) {
96291       {
96292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96293       };
96294     }
96295   }
96296
96297 }
96298
96299
96300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
96301   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96302   Dali::Toolkit::StyleManager arg2 ;
96303   Dali::StyleChange::Type arg3 ;
96304   Dali::Toolkit::StyleManager *argp2 ;
96305
96306   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96307   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
96308   if (!argp2) {
96309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
96310     return ;
96311   }
96312   arg2 = *argp2;
96313   arg3 = (Dali::StyleChange::Type)jarg3;
96314   {
96315     try {
96316       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
96317     } catch (std::out_of_range& e) {
96318       {
96319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96320       };
96321     } catch (std::exception& e) {
96322       {
96323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96324       };
96325     } catch (Dali::DaliException e) {
96326       {
96327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96328       };
96329     } catch (...) {
96330       {
96331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96332       };
96333     }
96334   }
96335
96336 }
96337
96338
96339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
96340   void * jresult ;
96341   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
96342
96343   {
96344     try {
96345       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
96346     } catch (std::out_of_range& e) {
96347       {
96348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96349       };
96350     } catch (std::exception& e) {
96351       {
96352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96353       };
96354     } catch (Dali::DaliException e) {
96355       {
96356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96357       };
96358     } catch (...) {
96359       {
96360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96361       };
96362     }
96363   }
96364
96365   jresult = (void *)result;
96366   return jresult;
96367 }
96368
96369
96370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
96371   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96372
96373   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96374   {
96375     try {
96376       delete arg1;
96377     } catch (std::out_of_range& e) {
96378       {
96379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96380       };
96381     } catch (std::exception& e) {
96382       {
96383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96384       };
96385     } catch (Dali::DaliException e) {
96386       {
96387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96388       };
96389     } catch (...) {
96390       {
96391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96392       };
96393     }
96394   }
96395
96396 }
96397
96398
96399 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
96400   unsigned int jresult ;
96401   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96402   bool result;
96403
96404   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96405   {
96406     try {
96407       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96408     } catch (std::out_of_range& e) {
96409       {
96410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96411       };
96412     } catch (std::exception& e) {
96413       {
96414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96415       };
96416     } catch (Dali::DaliException e) {
96417       {
96418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96419       };
96420     } catch (...) {
96421       {
96422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96423       };
96424     }
96425   }
96426
96427   jresult = result;
96428   return jresult;
96429 }
96430
96431
96432 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
96433   unsigned long jresult ;
96434   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96435   std::size_t result;
96436
96437   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96438   {
96439     try {
96440       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96441     } catch (std::out_of_range& e) {
96442       {
96443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96444       };
96445     } catch (std::exception& e) {
96446       {
96447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96448       };
96449     } catch (Dali::DaliException e) {
96450       {
96451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96452       };
96453     } catch (...) {
96454       {
96455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96456       };
96457     }
96458   }
96459
96460   jresult = (unsigned long)result;
96461   return jresult;
96462 }
96463
96464
96465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
96466   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96467   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96468
96469   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96470   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96471   {
96472     try {
96473       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
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 void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
96497   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96498   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96499
96500   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96501   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96502   {
96503     try {
96504       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
96505     } catch (std::out_of_range& e) {
96506       {
96507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96508       };
96509     } catch (std::exception& e) {
96510       {
96511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96512       };
96513     } catch (Dali::DaliException e) {
96514       {
96515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96516       };
96517     } catch (...) {
96518       {
96519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96520       };
96521     }
96522   }
96523
96524 }
96525
96526
96527 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
96528   unsigned int jresult ;
96529   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96530   Dali::Toolkit::Button arg2 ;
96531   Dali::Toolkit::Button *argp2 ;
96532   bool result;
96533
96534   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96535   argp2 = (Dali::Toolkit::Button *)jarg2;
96536   if (!argp2) {
96537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
96538     return 0;
96539   }
96540   arg2 = *argp2;
96541   {
96542     try {
96543       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
96544     } catch (std::out_of_range& e) {
96545       {
96546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96547       };
96548     } catch (std::exception& e) {
96549       {
96550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96551       };
96552     } catch (Dali::DaliException e) {
96553       {
96554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96555       };
96556     } catch (...) {
96557       {
96558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96559       };
96560     }
96561   }
96562
96563   jresult = result;
96564   return jresult;
96565 }
96566
96567
96568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
96569   void * jresult ;
96570   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
96571
96572   {
96573     try {
96574       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
96575     } catch (std::out_of_range& e) {
96576       {
96577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96578       };
96579     } catch (std::exception& e) {
96580       {
96581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96582       };
96583     } catch (Dali::DaliException e) {
96584       {
96585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96586       };
96587     } catch (...) {
96588       {
96589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96590       };
96591     }
96592   }
96593
96594   jresult = (void *)result;
96595   return jresult;
96596 }
96597
96598
96599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
96600   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96601
96602   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96603   {
96604     try {
96605       delete arg1;
96606     } catch (std::out_of_range& e) {
96607       {
96608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96609       };
96610     } catch (std::exception& e) {
96611       {
96612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96613       };
96614     } catch (Dali::DaliException e) {
96615       {
96616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96617       };
96618     } catch (...) {
96619       {
96620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96621       };
96622     }
96623   }
96624
96625 }
96626
96627
96628 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
96629   unsigned int jresult ;
96630   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96631   bool result;
96632
96633   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96634   {
96635     try {
96636       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
96637     } catch (std::out_of_range& e) {
96638       {
96639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96640       };
96641     } catch (std::exception& e) {
96642       {
96643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96644       };
96645     } catch (Dali::DaliException e) {
96646       {
96647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96648       };
96649     } catch (...) {
96650       {
96651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96652       };
96653     }
96654   }
96655
96656   jresult = result;
96657   return jresult;
96658 }
96659
96660
96661 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
96662   unsigned long jresult ;
96663   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96664   std::size_t result;
96665
96666   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96667   {
96668     try {
96669       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
96670     } catch (std::out_of_range& e) {
96671       {
96672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96673       };
96674     } catch (std::exception& e) {
96675       {
96676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96677       };
96678     } catch (Dali::DaliException e) {
96679       {
96680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96681       };
96682     } catch (...) {
96683       {
96684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96685       };
96686     }
96687   }
96688
96689   jresult = (unsigned long)result;
96690   return jresult;
96691 }
96692
96693
96694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
96695   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96696   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
96697
96698   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96699   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
96700   {
96701     try {
96702       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
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 void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
96726   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96727   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
96728
96729   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96730   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
96731   {
96732     try {
96733       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
96734     } catch (std::out_of_range& e) {
96735       {
96736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96737       };
96738     } catch (std::exception& e) {
96739       {
96740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96741       };
96742     } catch (Dali::DaliException e) {
96743       {
96744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96745       };
96746     } catch (...) {
96747       {
96748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96749       };
96750     }
96751   }
96752
96753 }
96754
96755
96756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
96757   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96758   Dali::Toolkit::GaussianBlurView arg2 ;
96759   Dali::Toolkit::GaussianBlurView *argp2 ;
96760
96761   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96762   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
96763   if (!argp2) {
96764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
96765     return ;
96766   }
96767   arg2 = *argp2;
96768   {
96769     try {
96770       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
96771     } catch (std::out_of_range& e) {
96772       {
96773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96774       };
96775     } catch (std::exception& e) {
96776       {
96777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96778       };
96779     } catch (Dali::DaliException e) {
96780       {
96781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96782       };
96783     } catch (...) {
96784       {
96785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96786       };
96787     }
96788   }
96789
96790 }
96791
96792
96793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
96794   void * jresult ;
96795   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
96796
96797   {
96798     try {
96799       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
96800     } catch (std::out_of_range& e) {
96801       {
96802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96803       };
96804     } catch (std::exception& e) {
96805       {
96806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96807       };
96808     } catch (Dali::DaliException e) {
96809       {
96810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96811       };
96812     } catch (...) {
96813       {
96814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96815       };
96816     }
96817   }
96818
96819   jresult = (void *)result;
96820   return jresult;
96821 }
96822
96823
96824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
96825   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96826
96827   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96828   {
96829     try {
96830       delete arg1;
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 unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
96854   unsigned int jresult ;
96855   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96856   bool result;
96857
96858   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96859   {
96860     try {
96861       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);
96862     } catch (std::out_of_range& e) {
96863       {
96864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96865       };
96866     } catch (std::exception& e) {
96867       {
96868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96869       };
96870     } catch (Dali::DaliException e) {
96871       {
96872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96873       };
96874     } catch (...) {
96875       {
96876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96877       };
96878     }
96879   }
96880
96881   jresult = result;
96882   return jresult;
96883 }
96884
96885
96886 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
96887   unsigned long jresult ;
96888   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96889   std::size_t result;
96890
96891   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96892   {
96893     try {
96894       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);
96895     } catch (std::out_of_range& e) {
96896       {
96897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96898       };
96899     } catch (std::exception& e) {
96900       {
96901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96902       };
96903     } catch (Dali::DaliException e) {
96904       {
96905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96906       };
96907     } catch (...) {
96908       {
96909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96910       };
96911     }
96912   }
96913
96914   jresult = (unsigned long)result;
96915   return jresult;
96916 }
96917
96918
96919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
96920   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96921   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
96922
96923   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96924   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
96925   {
96926     try {
96927       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
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 void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
96951   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96952   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
96953
96954   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96955   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
96956   {
96957     try {
96958       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
96959     } catch (std::out_of_range& e) {
96960       {
96961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96962       };
96963     } catch (std::exception& e) {
96964       {
96965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96966       };
96967     } catch (Dali::DaliException e) {
96968       {
96969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96970       };
96971     } catch (...) {
96972       {
96973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96974       };
96975     }
96976   }
96977
96978 }
96979
96980
96981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
96982   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96983   Dali::Toolkit::PageTurnView arg2 ;
96984   unsigned int arg3 ;
96985   bool arg4 ;
96986   Dali::Toolkit::PageTurnView *argp2 ;
96987
96988   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96989   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
96990   if (!argp2) {
96991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
96992     return ;
96993   }
96994   arg2 = *argp2;
96995   arg3 = (unsigned int)jarg3;
96996   arg4 = jarg4 ? true : false;
96997   {
96998     try {
96999       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
97000     } catch (std::out_of_range& e) {
97001       {
97002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97003       };
97004     } catch (std::exception& e) {
97005       {
97006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97007       };
97008     } catch (Dali::DaliException e) {
97009       {
97010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97011       };
97012     } catch (...) {
97013       {
97014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97015       };
97016     }
97017   }
97018
97019 }
97020
97021
97022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
97023   void * jresult ;
97024   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
97025
97026   {
97027     try {
97028       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
97029     } catch (std::out_of_range& e) {
97030       {
97031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97032       };
97033     } catch (std::exception& e) {
97034       {
97035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97036       };
97037     } catch (Dali::DaliException e) {
97038       {
97039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97040       };
97041     } catch (...) {
97042       {
97043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97044       };
97045     }
97046   }
97047
97048   jresult = (void *)result;
97049   return jresult;
97050 }
97051
97052
97053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
97054   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97055
97056   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97057   {
97058     try {
97059       delete arg1;
97060     } catch (std::out_of_range& e) {
97061       {
97062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97063       };
97064     } catch (std::exception& e) {
97065       {
97066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97067       };
97068     } catch (Dali::DaliException e) {
97069       {
97070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97071       };
97072     } catch (...) {
97073       {
97074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97075       };
97076     }
97077   }
97078
97079 }
97080
97081
97082 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
97083   unsigned int jresult ;
97084   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97085   bool result;
97086
97087   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97088   {
97089     try {
97090       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
97091     } catch (std::out_of_range& e) {
97092       {
97093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97094       };
97095     } catch (std::exception& e) {
97096       {
97097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97098       };
97099     } catch (Dali::DaliException e) {
97100       {
97101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97102       };
97103     } catch (...) {
97104       {
97105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97106       };
97107     }
97108   }
97109
97110   jresult = result;
97111   return jresult;
97112 }
97113
97114
97115 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
97116   unsigned long jresult ;
97117   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97118   std::size_t result;
97119
97120   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97121   {
97122     try {
97123       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
97124     } catch (std::out_of_range& e) {
97125       {
97126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97127       };
97128     } catch (std::exception& e) {
97129       {
97130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97131       };
97132     } catch (Dali::DaliException e) {
97133       {
97134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97135       };
97136     } catch (...) {
97137       {
97138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97139       };
97140     }
97141   }
97142
97143   jresult = (unsigned long)result;
97144   return jresult;
97145 }
97146
97147
97148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
97149   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97150   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
97151
97152   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97153   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
97154   {
97155     try {
97156       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
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 void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
97180   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97181   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
97182
97183   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97184   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
97185   {
97186     try {
97187       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
97188     } catch (std::out_of_range& e) {
97189       {
97190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97191       };
97192     } catch (std::exception& e) {
97193       {
97194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97195       };
97196     } catch (Dali::DaliException e) {
97197       {
97198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97199       };
97200     } catch (...) {
97201       {
97202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97203       };
97204     }
97205   }
97206
97207 }
97208
97209
97210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
97211   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97212   Dali::Toolkit::PageTurnView arg2 ;
97213   Dali::Toolkit::PageTurnView *argp2 ;
97214
97215   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97216   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
97217   if (!argp2) {
97218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
97219     return ;
97220   }
97221   arg2 = *argp2;
97222   {
97223     try {
97224       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
97225     } catch (std::out_of_range& e) {
97226       {
97227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97228       };
97229     } catch (std::exception& e) {
97230       {
97231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97232       };
97233     } catch (Dali::DaliException e) {
97234       {
97235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97236       };
97237     } catch (...) {
97238       {
97239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97240       };
97241     }
97242   }
97243
97244 }
97245
97246
97247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
97248   void * jresult ;
97249   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
97250
97251   {
97252     try {
97253       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
97254     } catch (std::out_of_range& e) {
97255       {
97256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97257       };
97258     } catch (std::exception& e) {
97259       {
97260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97261       };
97262     } catch (Dali::DaliException e) {
97263       {
97264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97265       };
97266     } catch (...) {
97267       {
97268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97269       };
97270     }
97271   }
97272
97273   jresult = (void *)result;
97274   return jresult;
97275 }
97276
97277
97278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
97279   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97280
97281   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97282   {
97283     try {
97284       delete arg1;
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 unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
97308   unsigned int jresult ;
97309   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97310   bool result;
97311
97312   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97313   {
97314     try {
97315       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);
97316     } catch (std::out_of_range& e) {
97317       {
97318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97319       };
97320     } catch (std::exception& e) {
97321       {
97322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97323       };
97324     } catch (Dali::DaliException e) {
97325       {
97326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97327       };
97328     } catch (...) {
97329       {
97330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97331       };
97332     }
97333   }
97334
97335   jresult = result;
97336   return jresult;
97337 }
97338
97339
97340 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
97341   unsigned long jresult ;
97342   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97343   std::size_t result;
97344
97345   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97346   {
97347     try {
97348       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);
97349     } catch (std::out_of_range& e) {
97350       {
97351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97352       };
97353     } catch (std::exception& e) {
97354       {
97355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97356       };
97357     } catch (Dali::DaliException e) {
97358       {
97359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97360       };
97361     } catch (...) {
97362       {
97363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97364       };
97365     }
97366   }
97367
97368   jresult = (unsigned long)result;
97369   return jresult;
97370 }
97371
97372
97373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
97374   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97375   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97376
97377   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97378   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97379   {
97380     try {
97381       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
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 void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
97405   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97406   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97407
97408   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97409   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97410   {
97411     try {
97412       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
97413     } catch (std::out_of_range& e) {
97414       {
97415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97416       };
97417     } catch (std::exception& e) {
97418       {
97419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97420       };
97421     } catch (Dali::DaliException e) {
97422       {
97423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97424       };
97425     } catch (...) {
97426       {
97427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97428       };
97429     }
97430   }
97431
97432 }
97433
97434
97435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
97436   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97437   Dali::Toolkit::ProgressBar arg2 ;
97438   float arg3 ;
97439   float arg4 ;
97440   Dali::Toolkit::ProgressBar *argp2 ;
97441
97442   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97443   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
97444   if (!argp2) {
97445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
97446     return ;
97447   }
97448   arg2 = *argp2;
97449   arg3 = (float)jarg3;
97450   arg4 = (float)jarg4;
97451   {
97452     try {
97453       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
97454     } catch (std::out_of_range& e) {
97455       {
97456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97457       };
97458     } catch (std::exception& e) {
97459       {
97460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97461       };
97462     } catch (Dali::DaliException e) {
97463       {
97464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97465       };
97466     } catch (...) {
97467       {
97468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97469       };
97470     }
97471   }
97472
97473 }
97474
97475
97476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
97477   void * jresult ;
97478   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
97479
97480   {
97481     try {
97482       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
97483     } catch (std::out_of_range& e) {
97484       {
97485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97486       };
97487     } catch (std::exception& e) {
97488       {
97489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97490       };
97491     } catch (Dali::DaliException e) {
97492       {
97493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97494       };
97495     } catch (...) {
97496       {
97497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97498       };
97499     }
97500   }
97501
97502   jresult = (void *)result;
97503   return jresult;
97504 }
97505
97506
97507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
97508   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97509
97510   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97511   {
97512     try {
97513       delete arg1;
97514     } catch (std::out_of_range& e) {
97515       {
97516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97517       };
97518     } catch (std::exception& e) {
97519       {
97520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97521       };
97522     } catch (Dali::DaliException e) {
97523       {
97524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97525       };
97526     } catch (...) {
97527       {
97528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97529       };
97530     }
97531   }
97532
97533 }
97534
97535
97536 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
97537   unsigned int jresult ;
97538   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97539   bool result;
97540
97541   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97542   {
97543     try {
97544       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);
97545     } catch (std::out_of_range& e) {
97546       {
97547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97548       };
97549     } catch (std::exception& e) {
97550       {
97551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97552       };
97553     } catch (Dali::DaliException e) {
97554       {
97555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97556       };
97557     } catch (...) {
97558       {
97559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97560       };
97561     }
97562   }
97563
97564   jresult = result;
97565   return jresult;
97566 }
97567
97568
97569 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
97570   unsigned long jresult ;
97571   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97572   std::size_t result;
97573
97574   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97575   {
97576     try {
97577       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);
97578     } catch (std::out_of_range& e) {
97579       {
97580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97581       };
97582     } catch (std::exception& e) {
97583       {
97584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97585       };
97586     } catch (Dali::DaliException e) {
97587       {
97588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97589       };
97590     } catch (...) {
97591       {
97592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97593       };
97594     }
97595   }
97596
97597   jresult = (unsigned long)result;
97598   return jresult;
97599 }
97600
97601
97602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
97603   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97604   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
97605
97606   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97607   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
97608   {
97609     try {
97610       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
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 void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
97634   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97635   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
97636
97637   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97638   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
97639   {
97640     try {
97641       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
97642     } catch (std::out_of_range& e) {
97643       {
97644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97645       };
97646     } catch (std::exception& e) {
97647       {
97648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97649       };
97650     } catch (Dali::DaliException e) {
97651       {
97652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97653       };
97654     } catch (...) {
97655       {
97656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97657       };
97658     }
97659   }
97660
97661 }
97662
97663
97664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
97665   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97666   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
97667
97668   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97669   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
97670   if (!arg2) {
97671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
97672     return ;
97673   }
97674   {
97675     try {
97676       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
97677     } catch (std::out_of_range& e) {
97678       {
97679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97680       };
97681     } catch (std::exception& e) {
97682       {
97683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97684       };
97685     } catch (Dali::DaliException e) {
97686       {
97687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97688       };
97689     } catch (...) {
97690       {
97691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97692       };
97693     }
97694   }
97695
97696 }
97697
97698
97699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
97700   void * jresult ;
97701   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
97702
97703   {
97704     try {
97705       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
97706     } catch (std::out_of_range& e) {
97707       {
97708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97709       };
97710     } catch (std::exception& e) {
97711       {
97712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97713       };
97714     } catch (Dali::DaliException e) {
97715       {
97716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97717       };
97718     } catch (...) {
97719       {
97720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97721       };
97722     }
97723   }
97724
97725   jresult = (void *)result;
97726   return jresult;
97727 }
97728
97729
97730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
97731   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97732
97733   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97734   {
97735     try {
97736       delete arg1;
97737     } catch (std::out_of_range& e) {
97738       {
97739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97740       };
97741     } catch (std::exception& e) {
97742       {
97743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97744       };
97745     } catch (Dali::DaliException e) {
97746       {
97747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97748       };
97749     } catch (...) {
97750       {
97751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97752       };
97753     }
97754   }
97755
97756 }
97757
97758
97759 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
97760   unsigned int jresult ;
97761   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97762   bool result;
97763
97764   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97765   {
97766     try {
97767       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
97768     } catch (std::out_of_range& e) {
97769       {
97770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97771       };
97772     } catch (std::exception& e) {
97773       {
97774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97775       };
97776     } catch (Dali::DaliException e) {
97777       {
97778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97779       };
97780     } catch (...) {
97781       {
97782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97783       };
97784     }
97785   }
97786
97787   jresult = result;
97788   return jresult;
97789 }
97790
97791
97792 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
97793   unsigned long jresult ;
97794   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97795   std::size_t result;
97796
97797   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97798   {
97799     try {
97800       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
97801     } catch (std::out_of_range& e) {
97802       {
97803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97804       };
97805     } catch (std::exception& e) {
97806       {
97807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97808       };
97809     } catch (Dali::DaliException e) {
97810       {
97811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97812       };
97813     } catch (...) {
97814       {
97815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97816       };
97817     }
97818   }
97819
97820   jresult = (unsigned long)result;
97821   return jresult;
97822 }
97823
97824
97825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
97826   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97827   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
97828
97829   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97830   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
97831   {
97832     try {
97833       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
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 void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
97857   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97858   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
97859
97860   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97861   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
97862   {
97863     try {
97864       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
97865     } catch (std::out_of_range& e) {
97866       {
97867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97868       };
97869     } catch (std::exception& e) {
97870       {
97871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97872       };
97873     } catch (Dali::DaliException e) {
97874       {
97875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97876       };
97877     } catch (...) {
97878       {
97879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97880       };
97881     }
97882   }
97883
97884 }
97885
97886
97887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
97888   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97889   Dali::Vector2 *arg2 = 0 ;
97890
97891   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97892   arg2 = (Dali::Vector2 *)jarg2;
97893   if (!arg2) {
97894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
97895     return ;
97896   }
97897   {
97898     try {
97899       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
97900     } catch (std::out_of_range& e) {
97901       {
97902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97903       };
97904     } catch (std::exception& e) {
97905       {
97906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97907       };
97908     } catch (Dali::DaliException e) {
97909       {
97910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97911       };
97912     } catch (...) {
97913       {
97914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97915       };
97916     }
97917   }
97918
97919 }
97920
97921
97922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
97923   void * jresult ;
97924   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
97925
97926   {
97927     try {
97928       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
97929     } catch (std::out_of_range& e) {
97930       {
97931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97932       };
97933     } catch (std::exception& e) {
97934       {
97935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97936       };
97937     } catch (Dali::DaliException e) {
97938       {
97939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97940       };
97941     } catch (...) {
97942       {
97943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97944       };
97945     }
97946   }
97947
97948   jresult = (void *)result;
97949   return jresult;
97950 }
97951
97952
97953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
97954   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97955
97956   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97957   {
97958     try {
97959       delete arg1;
97960     } catch (std::out_of_range& e) {
97961       {
97962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97963       };
97964     } catch (std::exception& e) {
97965       {
97966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97967       };
97968     } catch (Dali::DaliException e) {
97969       {
97970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97971       };
97972     } catch (...) {
97973       {
97974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97975       };
97976     }
97977   }
97978
97979 }
97980
97981
97982
97983 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
97984   unsigned int jresult ;
97985   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97986   bool result;
97987
97988   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97989   {
97990     try {
97991       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);
97992     } catch (std::out_of_range& e) {
97993       {
97994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97995       };
97996     } catch (std::exception& e) {
97997       {
97998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97999       };
98000     } catch (Dali::DaliException e) {
98001       {
98002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98003       };
98004     } catch (...) {
98005       {
98006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98007       };
98008     }
98009   }
98010
98011   jresult = result;
98012   return jresult;
98013 }
98014
98015
98016 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
98017   unsigned long jresult ;
98018   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98019   std::size_t result;
98020
98021   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98022   {
98023     try {
98024       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);
98025     } catch (std::out_of_range& e) {
98026       {
98027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98028       };
98029     } catch (std::exception& e) {
98030       {
98031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98032       };
98033     } catch (Dali::DaliException e) {
98034       {
98035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98036       };
98037     } catch (...) {
98038       {
98039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98040       };
98041     }
98042   }
98043
98044   jresult = (unsigned long)result;
98045   return jresult;
98046 }
98047
98048
98049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
98050   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98051   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
98052
98053   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98054   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
98055   {
98056     try {
98057       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
98058     } catch (std::out_of_range& e) {
98059       {
98060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98061       };
98062     } catch (std::exception& e) {
98063       {
98064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98065       };
98066     } catch (Dali::DaliException e) {
98067       {
98068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98069       };
98070     } catch (...) {
98071       {
98072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98073       };
98074     }
98075   }
98076
98077 }
98078
98079
98080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
98081   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98082   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
98083
98084   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98085   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
98086   {
98087     try {
98088       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98089     } catch (std::out_of_range& e) {
98090       {
98091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98092       };
98093     } catch (std::exception& e) {
98094       {
98095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98096       };
98097     } catch (Dali::DaliException e) {
98098       {
98099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98100       };
98101     } catch (...) {
98102       {
98103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98104       };
98105     }
98106   }
98107
98108 }
98109
98110
98111 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
98112   unsigned int jresult ;
98113   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98114   Dali::Toolkit::Control arg2 ;
98115   Dali::KeyEvent *arg3 = 0 ;
98116   Dali::Toolkit::Control *argp2 ;
98117   bool result;
98118
98119   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98120   argp2 = (Dali::Toolkit::Control *)jarg2;
98121   if (!argp2) {
98122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98123     return 0;
98124   }
98125   arg2 = *argp2;
98126   arg3 = (Dali::KeyEvent *)jarg3;
98127   if (!arg3) {
98128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
98129     return 0;
98130   }
98131   {
98132     try {
98133       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);
98134     } catch (std::out_of_range& e) {
98135       {
98136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98137       };
98138     } catch (std::exception& e) {
98139       {
98140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98141       };
98142     } catch (Dali::DaliException e) {
98143       {
98144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98145       };
98146     } catch (...) {
98147       {
98148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98149       };
98150     }
98151   }
98152
98153   jresult = result;
98154   return jresult;
98155 }
98156
98157
98158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
98159   void * jresult ;
98160   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
98161
98162   {
98163     try {
98164       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
98165     } catch (std::out_of_range& e) {
98166       {
98167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98168       };
98169     } catch (std::exception& e) {
98170       {
98171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98172       };
98173     } catch (Dali::DaliException e) {
98174       {
98175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98176       };
98177     } catch (...) {
98178       {
98179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98180       };
98181     }
98182   }
98183
98184   jresult = (void *)result;
98185   return jresult;
98186 }
98187
98188
98189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
98190   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98191
98192   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98193   {
98194     try {
98195       delete arg1;
98196     } catch (std::out_of_range& e) {
98197       {
98198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98199       };
98200     } catch (std::exception& e) {
98201       {
98202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98203       };
98204     } catch (Dali::DaliException e) {
98205       {
98206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98207       };
98208     } catch (...) {
98209       {
98210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98211       };
98212     }
98213   }
98214
98215 }
98216
98217
98218 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
98219   unsigned int jresult ;
98220   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98221   bool result;
98222
98223   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98224   {
98225     try {
98226       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98227     } catch (std::out_of_range& e) {
98228       {
98229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98230       };
98231     } catch (std::exception& e) {
98232       {
98233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98234       };
98235     } catch (Dali::DaliException e) {
98236       {
98237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98238       };
98239     } catch (...) {
98240       {
98241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98242       };
98243     }
98244   }
98245
98246   jresult = result;
98247   return jresult;
98248 }
98249
98250
98251 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
98252   unsigned long jresult ;
98253   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98254   std::size_t result;
98255
98256   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98257   {
98258     try {
98259       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98260     } catch (std::out_of_range& e) {
98261       {
98262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98263       };
98264     } catch (std::exception& e) {
98265       {
98266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98267       };
98268     } catch (Dali::DaliException e) {
98269       {
98270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98271       };
98272     } catch (...) {
98273       {
98274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98275       };
98276     }
98277   }
98278
98279   jresult = (unsigned long)result;
98280   return jresult;
98281 }
98282
98283
98284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
98285   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98286   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98287
98288   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98289   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98290   {
98291     try {
98292       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
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 void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
98316   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98317   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98318
98319   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98320   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98321   {
98322     try {
98323       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
98324     } catch (std::out_of_range& e) {
98325       {
98326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98327       };
98328     } catch (std::exception& e) {
98329       {
98330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98331       };
98332     } catch (Dali::DaliException e) {
98333       {
98334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98335       };
98336     } catch (...) {
98337       {
98338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98339       };
98340     }
98341   }
98342
98343 }
98344
98345
98346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
98347   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98348   Dali::Toolkit::Control arg2 ;
98349   Dali::Toolkit::Control *argp2 ;
98350
98351   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98352   argp2 = (Dali::Toolkit::Control *)jarg2;
98353   if (!argp2) {
98354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98355     return ;
98356   }
98357   arg2 = *argp2;
98358   {
98359     try {
98360       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
98361     } catch (std::out_of_range& e) {
98362       {
98363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98364       };
98365     } catch (std::exception& e) {
98366       {
98367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98368       };
98369     } catch (Dali::DaliException e) {
98370       {
98371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98372       };
98373     } catch (...) {
98374       {
98375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98376       };
98377     }
98378   }
98379
98380 }
98381
98382
98383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
98384   void * jresult ;
98385   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
98386
98387   {
98388     try {
98389       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
98390     } catch (std::out_of_range& e) {
98391       {
98392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98393       };
98394     } catch (std::exception& e) {
98395       {
98396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98397       };
98398     } catch (Dali::DaliException e) {
98399       {
98400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98401       };
98402     } catch (...) {
98403       {
98404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98405       };
98406     }
98407   }
98408
98409   jresult = (void *)result;
98410   return jresult;
98411 }
98412
98413
98414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
98415   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98416
98417   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98418   {
98419     try {
98420       delete arg1;
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 unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
98444   unsigned int jresult ;
98445   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98446   bool result;
98447
98448   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98449   {
98450     try {
98451       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98452     } catch (std::out_of_range& e) {
98453       {
98454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98455       };
98456     } catch (std::exception& e) {
98457       {
98458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98459       };
98460     } catch (Dali::DaliException e) {
98461       {
98462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98463       };
98464     } catch (...) {
98465       {
98466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98467       };
98468     }
98469   }
98470
98471   jresult = result;
98472   return jresult;
98473 }
98474
98475
98476 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
98477   unsigned long jresult ;
98478   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98479   std::size_t result;
98480
98481   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98482   {
98483     try {
98484       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98485     } catch (std::out_of_range& e) {
98486       {
98487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98488       };
98489     } catch (std::exception& e) {
98490       {
98491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98492       };
98493     } catch (Dali::DaliException e) {
98494       {
98495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98496       };
98497     } catch (...) {
98498       {
98499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98500       };
98501     }
98502   }
98503
98504   jresult = (unsigned long)result;
98505   return jresult;
98506 }
98507
98508
98509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
98510   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98511   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
98512
98513   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98514   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
98515   {
98516     try {
98517       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
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 void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
98541   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98542   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
98543
98544   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98545   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
98546   {
98547     try {
98548       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
98549     } catch (std::out_of_range& e) {
98550       {
98551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98552       };
98553     } catch (std::exception& e) {
98554       {
98555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98556       };
98557     } catch (Dali::DaliException e) {
98558       {
98559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98560       };
98561     } catch (...) {
98562       {
98563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98564       };
98565     }
98566   }
98567
98568 }
98569
98570
98571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
98572   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98573   Dali::Toolkit::VideoView *arg2 = 0 ;
98574
98575   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98576   arg2 = (Dali::Toolkit::VideoView *)jarg2;
98577   if (!arg2) {
98578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
98579     return ;
98580   }
98581   {
98582     try {
98583       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
98584     } catch (std::out_of_range& e) {
98585       {
98586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98587       };
98588     } catch (std::exception& e) {
98589       {
98590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98591       };
98592     } catch (Dali::DaliException e) {
98593       {
98594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98595       };
98596     } catch (...) {
98597       {
98598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98599       };
98600     }
98601   }
98602
98603 }
98604
98605
98606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
98607   void * jresult ;
98608   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
98609
98610   {
98611     try {
98612       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
98613     } catch (std::out_of_range& e) {
98614       {
98615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98616       };
98617     } catch (std::exception& e) {
98618       {
98619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98620       };
98621     } catch (Dali::DaliException e) {
98622       {
98623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98624       };
98625     } catch (...) {
98626       {
98627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98628       };
98629     }
98630   }
98631
98632   jresult = (void *)result;
98633   return jresult;
98634 }
98635
98636
98637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
98638   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98639
98640   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98641   {
98642     try {
98643       delete arg1;
98644     } catch (std::out_of_range& e) {
98645       {
98646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98647       };
98648     } catch (std::exception& e) {
98649       {
98650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98651       };
98652     } catch (Dali::DaliException e) {
98653       {
98654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98655       };
98656     } catch (...) {
98657       {
98658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98659       };
98660     }
98661   }
98662
98663 }
98664
98665
98666 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
98667   unsigned int jresult ;
98668   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98669   bool result;
98670
98671   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98672   {
98673     try {
98674       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
98675     } catch (std::out_of_range& e) {
98676       {
98677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98678       };
98679     } catch (std::exception& e) {
98680       {
98681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98682       };
98683     } catch (Dali::DaliException e) {
98684       {
98685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98686       };
98687     } catch (...) {
98688       {
98689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98690       };
98691     }
98692   }
98693
98694   jresult = result;
98695   return jresult;
98696 }
98697
98698
98699 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
98700   unsigned long jresult ;
98701   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98702   std::size_t result;
98703
98704   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98705   {
98706     try {
98707       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
98708     } catch (std::out_of_range& e) {
98709       {
98710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98711       };
98712     } catch (std::exception& e) {
98713       {
98714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98715       };
98716     } catch (Dali::DaliException e) {
98717       {
98718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98719       };
98720     } catch (...) {
98721       {
98722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98723       };
98724     }
98725   }
98726
98727   jresult = (unsigned long)result;
98728   return jresult;
98729 }
98730
98731
98732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
98733   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98734   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
98735
98736   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98737   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
98738   {
98739     try {
98740       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
98741     } catch (std::out_of_range& e) {
98742       {
98743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98744       };
98745     } catch (std::exception& e) {
98746       {
98747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98748       };
98749     } catch (Dali::DaliException e) {
98750       {
98751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98752       };
98753     } catch (...) {
98754       {
98755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98756       };
98757     }
98758   }
98759
98760 }
98761
98762
98763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
98764   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98765   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
98766
98767   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98768   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
98769   {
98770     try {
98771       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
98772     } catch (std::out_of_range& e) {
98773       {
98774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98775       };
98776     } catch (std::exception& e) {
98777       {
98778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98779       };
98780     } catch (Dali::DaliException e) {
98781       {
98782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98783       };
98784     } catch (...) {
98785       {
98786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98787       };
98788     }
98789   }
98790
98791 }
98792
98793
98794 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
98795   unsigned int jresult ;
98796   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98797   Dali::Toolkit::Slider arg2 ;
98798   float arg3 ;
98799   Dali::Toolkit::Slider *argp2 ;
98800   bool result;
98801
98802   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98803   argp2 = (Dali::Toolkit::Slider *)jarg2;
98804   if (!argp2) {
98805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
98806     return 0;
98807   }
98808   arg2 = *argp2;
98809   arg3 = (float)jarg3;
98810   {
98811     try {
98812       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
98813     } catch (std::out_of_range& e) {
98814       {
98815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98816       };
98817     } catch (std::exception& e) {
98818       {
98819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98820       };
98821     } catch (Dali::DaliException e) {
98822       {
98823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98824       };
98825     } catch (...) {
98826       {
98827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98828       };
98829     }
98830   }
98831
98832   jresult = result;
98833   return jresult;
98834 }
98835
98836
98837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
98838   void * jresult ;
98839   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
98840
98841   {
98842     try {
98843       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
98844     } catch (std::out_of_range& e) {
98845       {
98846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98847       };
98848     } catch (std::exception& e) {
98849       {
98850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98851       };
98852     } catch (Dali::DaliException e) {
98853       {
98854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98855       };
98856     } catch (...) {
98857       {
98858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98859       };
98860     }
98861   }
98862
98863   jresult = (void *)result;
98864   return jresult;
98865 }
98866
98867
98868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
98869   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98870
98871   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98872   {
98873     try {
98874       delete arg1;
98875     } catch (std::out_of_range& e) {
98876       {
98877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98878       };
98879     } catch (std::exception& e) {
98880       {
98881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98882       };
98883     } catch (Dali::DaliException e) {
98884       {
98885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98886       };
98887     } catch (...) {
98888       {
98889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98890       };
98891     }
98892   }
98893
98894 }
98895
98896
98897 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
98898   unsigned int jresult ;
98899   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98900   bool result;
98901
98902   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98903   {
98904     try {
98905       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
98906     } catch (std::out_of_range& e) {
98907       {
98908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98909       };
98910     } catch (std::exception& e) {
98911       {
98912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98913       };
98914     } catch (Dali::DaliException e) {
98915       {
98916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98917       };
98918     } catch (...) {
98919       {
98920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98921       };
98922     }
98923   }
98924
98925   jresult = result;
98926   return jresult;
98927 }
98928
98929
98930 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
98931   unsigned long jresult ;
98932   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98933   std::size_t result;
98934
98935   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98936   {
98937     try {
98938       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
98939     } catch (std::out_of_range& e) {
98940       {
98941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98942       };
98943     } catch (std::exception& e) {
98944       {
98945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98946       };
98947     } catch (Dali::DaliException e) {
98948       {
98949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98950       };
98951     } catch (...) {
98952       {
98953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98954       };
98955     }
98956   }
98957
98958   jresult = (unsigned long)result;
98959   return jresult;
98960 }
98961
98962
98963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
98964   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98965   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
98966
98967   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98968   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
98969   {
98970     try {
98971       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
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 void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
98995   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98996   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
98997
98998   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98999   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
99000   {
99001     try {
99002       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
99003     } catch (std::out_of_range& e) {
99004       {
99005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99006       };
99007     } catch (std::exception& e) {
99008       {
99009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99010       };
99011     } catch (Dali::DaliException e) {
99012       {
99013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99014       };
99015     } catch (...) {
99016       {
99017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99018       };
99019     }
99020   }
99021
99022 }
99023
99024
99025 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
99026   unsigned int jresult ;
99027   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99028   Dali::Toolkit::Slider arg2 ;
99029   int arg3 ;
99030   Dali::Toolkit::Slider *argp2 ;
99031   bool result;
99032
99033   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99034   argp2 = (Dali::Toolkit::Slider *)jarg2;
99035   if (!argp2) {
99036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
99037     return 0;
99038   }
99039   arg2 = *argp2;
99040   arg3 = (int)jarg3;
99041   {
99042     try {
99043       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
99044     } catch (std::out_of_range& e) {
99045       {
99046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99047       };
99048     } catch (std::exception& e) {
99049       {
99050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99051       };
99052     } catch (Dali::DaliException e) {
99053       {
99054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99055       };
99056     } catch (...) {
99057       {
99058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99059       };
99060     }
99061   }
99062
99063   jresult = result;
99064   return jresult;
99065 }
99066
99067
99068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
99069   void * jresult ;
99070   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
99071
99072   {
99073     try {
99074       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
99075     } catch (std::out_of_range& e) {
99076       {
99077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99078       };
99079     } catch (std::exception& e) {
99080       {
99081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99082       };
99083     } catch (Dali::DaliException e) {
99084       {
99085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99086       };
99087     } catch (...) {
99088       {
99089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99090       };
99091     }
99092   }
99093
99094   jresult = (void *)result;
99095   return jresult;
99096 }
99097
99098
99099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
99100   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99101
99102   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99103   {
99104     try {
99105       delete arg1;
99106     } catch (std::out_of_range& e) {
99107       {
99108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99109       };
99110     } catch (std::exception& e) {
99111       {
99112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99113       };
99114     } catch (Dali::DaliException e) {
99115       {
99116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99117       };
99118     } catch (...) {
99119       {
99120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99121       };
99122     }
99123   }
99124
99125 }
99126
99127
99128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
99129   void * jresult ;
99130   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99131
99132   {
99133     try {
99134       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
99135     } catch (std::out_of_range& e) {
99136       {
99137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99138       };
99139     } catch (std::exception& e) {
99140       {
99141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99142       };
99143     } catch (Dali::DaliException e) {
99144       {
99145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99146       };
99147     } catch (...) {
99148       {
99149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99150       };
99151     }
99152   }
99153
99154   jresult = (void *)result;
99155   return jresult;
99156 }
99157
99158
99159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
99160   void * jresult ;
99161   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
99162   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99163
99164   arg1 = (Dali::Toolkit::Ruler *)jarg1;
99165   {
99166     try {
99167       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
99168     } catch (std::out_of_range& e) {
99169       {
99170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99171       };
99172     } catch (std::exception& e) {
99173       {
99174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99175       };
99176     } catch (Dali::DaliException e) {
99177       {
99178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99179       };
99180     } catch (...) {
99181       {
99182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99183       };
99184     }
99185   }
99186
99187   jresult = (void *)result;
99188   return jresult;
99189 }
99190
99191
99192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
99193   void * jresult ;
99194   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
99195   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99196
99197   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99198   if (!arg1) {
99199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99200     return 0;
99201   }
99202   {
99203     try {
99204       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
99205     } catch (std::out_of_range& e) {
99206       {
99207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99208       };
99209     } catch (std::exception& e) {
99210       {
99211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99212       };
99213     } catch (Dali::DaliException e) {
99214       {
99215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99216       };
99217     } catch (...) {
99218       {
99219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99220       };
99221     }
99222   }
99223
99224   jresult = (void *)result;
99225   return jresult;
99226 }
99227
99228
99229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
99230   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99231
99232   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99233   {
99234     try {
99235       delete arg1;
99236     } catch (std::out_of_range& e) {
99237       {
99238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99239       };
99240     } catch (std::exception& e) {
99241       {
99242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99243       };
99244     } catch (Dali::DaliException e) {
99245       {
99246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99247       };
99248     } catch (...) {
99249       {
99250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99251       };
99252     }
99253   }
99254
99255 }
99256
99257
99258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
99259   void * jresult ;
99260   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99261   Dali::Toolkit::Ruler *result = 0 ;
99262
99263   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99264   {
99265     try {
99266       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
99267     } catch (std::out_of_range& e) {
99268       {
99269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99270       };
99271     } catch (std::exception& e) {
99272       {
99273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99274       };
99275     } catch (Dali::DaliException e) {
99276       {
99277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99278       };
99279     } catch (...) {
99280       {
99281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99282       };
99283     }
99284   }
99285
99286   jresult = (void *)result;
99287   return jresult;
99288 }
99289
99290
99291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
99292   void * jresult ;
99293   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99294   Dali::Toolkit::Ruler *result = 0 ;
99295
99296   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99297   {
99298     try {
99299       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
99300     } catch (std::out_of_range& e) {
99301       {
99302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99303       };
99304     } catch (std::exception& e) {
99305       {
99306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99307       };
99308     } catch (Dali::DaliException e) {
99309       {
99310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99311       };
99312     } catch (...) {
99313       {
99314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99315       };
99316     }
99317   }
99318
99319   jresult = (void *)result;
99320   return jresult;
99321 }
99322
99323
99324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
99325   void * jresult ;
99326   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99327   Dali::Toolkit::Ruler *result = 0 ;
99328
99329   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99330   {
99331     try {
99332       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
99333     } catch (std::out_of_range& e) {
99334       {
99335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99336       };
99337     } catch (std::exception& e) {
99338       {
99339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99340       };
99341     } catch (Dali::DaliException e) {
99342       {
99343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99344       };
99345     } catch (...) {
99346       {
99347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99348       };
99349     }
99350   }
99351
99352   jresult = (void *)result;
99353   return jresult;
99354 }
99355
99356
99357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
99358   void * jresult ;
99359   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99360   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
99361   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99362
99363   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99364   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
99365   if (!arg2) {
99366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99367     return 0;
99368   }
99369   {
99370     try {
99371       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
99372     } catch (std::out_of_range& e) {
99373       {
99374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99375       };
99376     } catch (std::exception& e) {
99377       {
99378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99379       };
99380     } catch (Dali::DaliException e) {
99381       {
99382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99383       };
99384     } catch (...) {
99385       {
99386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99387       };
99388     }
99389   }
99390
99391   jresult = (void *)result;
99392   return jresult;
99393 }
99394
99395
99396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
99397   void * jresult ;
99398   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99399   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99400   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99401
99402   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99403   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99404   {
99405     try {
99406       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
99407     } catch (std::out_of_range& e) {
99408       {
99409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99410       };
99411     } catch (std::exception& e) {
99412       {
99413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99414       };
99415     } catch (Dali::DaliException e) {
99416       {
99417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99418       };
99419     } catch (...) {
99420       {
99421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99422       };
99423     }
99424   }
99425
99426   jresult = (void *)result;
99427   return jresult;
99428 }
99429
99430
99431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
99432   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99433
99434   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99435   {
99436     try {
99437       (arg1)->Reset();
99438     } catch (std::out_of_range& e) {
99439       {
99440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99441       };
99442     } catch (std::exception& e) {
99443       {
99444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99445       };
99446     } catch (Dali::DaliException e) {
99447       {
99448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99449       };
99450     } catch (...) {
99451       {
99452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99453       };
99454     }
99455   }
99456
99457 }
99458
99459
99460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
99461   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99462   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99463
99464   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99465   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99466   {
99467     try {
99468       (arg1)->Reset(arg2);
99469     } catch (std::out_of_range& e) {
99470       {
99471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99472       };
99473     } catch (std::exception& e) {
99474       {
99475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99476       };
99477     } catch (Dali::DaliException e) {
99478       {
99479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99480       };
99481     } catch (...) {
99482       {
99483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99484       };
99485     }
99486   }
99487
99488 }
99489
99490
99491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
99492   void * jresult ;
99493   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99494   Dali::Toolkit::Ruler *result = 0 ;
99495
99496   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99497   {
99498     try {
99499       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
99500     } catch (std::out_of_range& e) {
99501       {
99502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99503       };
99504     } catch (std::exception& e) {
99505       {
99506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99507       };
99508     } catch (Dali::DaliException e) {
99509       {
99510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99511       };
99512     } catch (...) {
99513       {
99514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99515       };
99516     }
99517   }
99518
99519   jresult = (void *)result;
99520   return jresult;
99521 }
99522
99523
99524 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
99525   float jresult ;
99526   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99527   float arg2 ;
99528   float arg3 ;
99529   float result;
99530
99531   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99532   arg2 = (float)jarg2;
99533   arg3 = (float)jarg3;
99534   {
99535     try {
99536       result = (float)(*arg1)->Snap(arg2,arg3);
99537     } catch (std::out_of_range& e) {
99538       {
99539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99540       };
99541     } catch (std::exception& e) {
99542       {
99543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99544       };
99545     } catch (Dali::DaliException e) {
99546       {
99547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99548       };
99549     } catch (...) {
99550       {
99551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99552       };
99553     }
99554   }
99555
99556   jresult = result;
99557   return jresult;
99558 }
99559
99560
99561 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
99562   float jresult ;
99563   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99564   float arg2 ;
99565   float result;
99566
99567   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99568   arg2 = (float)jarg2;
99569   {
99570     try {
99571       result = (float)(*arg1)->Snap(arg2);
99572     } catch (std::out_of_range& e) {
99573       {
99574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99575       };
99576     } catch (std::exception& e) {
99577       {
99578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99579       };
99580     } catch (Dali::DaliException e) {
99581       {
99582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99583       };
99584     } catch (...) {
99585       {
99586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99587       };
99588     }
99589   }
99590
99591   jresult = result;
99592   return jresult;
99593 }
99594
99595
99596 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
99597   float jresult ;
99598   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99599   unsigned int arg2 ;
99600   unsigned int *arg3 = 0 ;
99601   bool arg4 ;
99602   float result;
99603
99604   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99605   arg2 = (unsigned int)jarg2;
99606   arg3 = (unsigned int *)jarg3;
99607   arg4 = jarg4 ? true : false;
99608   {
99609     try {
99610       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
99611     } catch (std::out_of_range& e) {
99612       {
99613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99614       };
99615     } catch (std::exception& e) {
99616       {
99617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99618       };
99619     } catch (Dali::DaliException e) {
99620       {
99621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99622       };
99623     } catch (...) {
99624       {
99625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99626       };
99627     }
99628   }
99629
99630   jresult = result;
99631   return jresult;
99632 }
99633
99634
99635 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
99636   unsigned int jresult ;
99637   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99638   float arg2 ;
99639   bool arg3 ;
99640   unsigned int result;
99641
99642   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99643   arg2 = (float)jarg2;
99644   arg3 = jarg3 ? true : false;
99645   {
99646     try {
99647       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
99648     } catch (std::out_of_range& e) {
99649       {
99650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99651       };
99652     } catch (std::exception& e) {
99653       {
99654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99655       };
99656     } catch (Dali::DaliException e) {
99657       {
99658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99659       };
99660     } catch (...) {
99661       {
99662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99663       };
99664     }
99665   }
99666
99667   jresult = result;
99668   return jresult;
99669 }
99670
99671
99672 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
99673   unsigned int jresult ;
99674   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99675   unsigned int result;
99676
99677   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99678   {
99679     try {
99680       result = (unsigned int)(*arg1)->GetTotalPages();
99681     } catch (std::out_of_range& e) {
99682       {
99683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99684       };
99685     } catch (std::exception& e) {
99686       {
99687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99688       };
99689     } catch (Dali::DaliException e) {
99690       {
99691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99692       };
99693     } catch (...) {
99694       {
99695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99696       };
99697     }
99698   }
99699
99700   jresult = result;
99701   return jresult;
99702 }
99703
99704
99705 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
99706   int jresult ;
99707   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99708   Dali::Toolkit::Ruler::RulerType result;
99709
99710   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99711   {
99712     try {
99713       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
99714     } catch (std::out_of_range& e) {
99715       {
99716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99717       };
99718     } catch (std::exception& e) {
99719       {
99720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99721       };
99722     } catch (Dali::DaliException e) {
99723       {
99724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99725       };
99726     } catch (...) {
99727       {
99728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99729       };
99730     }
99731   }
99732
99733   jresult = (int)result;
99734   return jresult;
99735 }
99736
99737
99738 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
99739   unsigned int jresult ;
99740   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99741   bool result;
99742
99743   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99744   {
99745     try {
99746       result = (bool)(*arg1)->IsEnabled();
99747     } catch (std::out_of_range& e) {
99748       {
99749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99750       };
99751     } catch (std::exception& e) {
99752       {
99753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99754       };
99755     } catch (Dali::DaliException e) {
99756       {
99757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99758       };
99759     } catch (...) {
99760       {
99761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99762       };
99763     }
99764   }
99765
99766   jresult = result;
99767   return jresult;
99768 }
99769
99770
99771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
99772   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99773
99774   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99775   {
99776     try {
99777       (*arg1)->Enable();
99778     } catch (std::out_of_range& e) {
99779       {
99780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99781       };
99782     } catch (std::exception& e) {
99783       {
99784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99785       };
99786     } catch (Dali::DaliException e) {
99787       {
99788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99789       };
99790     } catch (...) {
99791       {
99792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99793       };
99794     }
99795   }
99796
99797 }
99798
99799
99800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
99801   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99802
99803   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99804   {
99805     try {
99806       (*arg1)->Disable();
99807     } catch (std::out_of_range& e) {
99808       {
99809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99810       };
99811     } catch (std::exception& e) {
99812       {
99813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99814       };
99815     } catch (Dali::DaliException e) {
99816       {
99817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99818       };
99819     } catch (...) {
99820       {
99821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99822       };
99823     }
99824   }
99825
99826 }
99827
99828
99829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
99830   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99831   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
99832   Dali::Toolkit::RulerDomain *argp2 ;
99833
99834   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99835   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
99836   if (!argp2) {
99837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
99838     return ;
99839   }
99840   arg2 = *argp2;
99841   {
99842     try {
99843       (*arg1)->SetDomain(arg2);
99844     } catch (std::out_of_range& e) {
99845       {
99846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99847       };
99848     } catch (std::exception& e) {
99849       {
99850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99851       };
99852     } catch (Dali::DaliException e) {
99853       {
99854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99855       };
99856     } catch (...) {
99857       {
99858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99859       };
99860     }
99861   }
99862
99863 }
99864
99865
99866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
99867   void * jresult ;
99868   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99869   Dali::Toolkit::RulerDomain *result = 0 ;
99870
99871   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99872   {
99873     try {
99874       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
99875     } catch (std::out_of_range& e) {
99876       {
99877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99878       };
99879     } catch (std::exception& e) {
99880       {
99881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99882       };
99883     } catch (Dali::DaliException e) {
99884       {
99885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99886       };
99887     } catch (...) {
99888       {
99889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99890       };
99891     }
99892   }
99893
99894   jresult = (void *)result;
99895   return jresult;
99896 }
99897
99898
99899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
99900   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99901
99902   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99903   {
99904     try {
99905       (*arg1)->DisableDomain();
99906     } catch (std::out_of_range& e) {
99907       {
99908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99909       };
99910     } catch (std::exception& e) {
99911       {
99912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99913       };
99914     } catch (Dali::DaliException e) {
99915       {
99916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99917       };
99918     } catch (...) {
99919       {
99920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99921       };
99922     }
99923   }
99924
99925 }
99926
99927
99928 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
99929   float jresult ;
99930   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99931   float arg2 ;
99932   float arg3 ;
99933   float arg4 ;
99934   float result;
99935
99936   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99937   arg2 = (float)jarg2;
99938   arg3 = (float)jarg3;
99939   arg4 = (float)jarg4;
99940   {
99941     try {
99942       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
99943     } catch (std::out_of_range& e) {
99944       {
99945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99946       };
99947     } catch (std::exception& e) {
99948       {
99949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99950       };
99951     } catch (Dali::DaliException e) {
99952       {
99953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99954       };
99955     } catch (...) {
99956       {
99957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99958       };
99959     }
99960   }
99961
99962   jresult = result;
99963   return jresult;
99964 }
99965
99966
99967 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
99968   float jresult ;
99969   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99970   float arg2 ;
99971   float arg3 ;
99972   float result;
99973
99974   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99975   arg2 = (float)jarg2;
99976   arg3 = (float)jarg3;
99977   {
99978     try {
99979       result = (float)(*arg1)->Clamp(arg2,arg3);
99980     } catch (std::out_of_range& e) {
99981       {
99982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99983       };
99984     } catch (std::exception& e) {
99985       {
99986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99987       };
99988     } catch (Dali::DaliException e) {
99989       {
99990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99991       };
99992     } catch (...) {
99993       {
99994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99995       };
99996     }
99997   }
99998
99999   jresult = result;
100000   return jresult;
100001 }
100002
100003
100004 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
100005   float jresult ;
100006   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100007   float arg2 ;
100008   float result;
100009
100010   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100011   arg2 = (float)jarg2;
100012   {
100013     try {
100014       result = (float)(*arg1)->Clamp(arg2);
100015     } catch (std::out_of_range& e) {
100016       {
100017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100018       };
100019     } catch (std::exception& e) {
100020       {
100021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100022       };
100023     } catch (Dali::DaliException e) {
100024       {
100025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100026       };
100027     } catch (...) {
100028       {
100029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100030       };
100031     }
100032   }
100033
100034   jresult = result;
100035   return jresult;
100036 }
100037
100038
100039 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
100040   float jresult ;
100041   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100042   float arg2 ;
100043   float arg3 ;
100044   float arg4 ;
100045   Dali::Toolkit::ClampState *arg5 = 0 ;
100046   float result;
100047
100048   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100049   arg2 = (float)jarg2;
100050   arg3 = (float)jarg3;
100051   arg4 = (float)jarg4;
100052   arg5 = (Dali::Toolkit::ClampState *)jarg5;
100053   if (!arg5) {
100054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100055     return 0;
100056   }
100057   {
100058     try {
100059       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
100060     } catch (std::out_of_range& e) {
100061       {
100062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100063       };
100064     } catch (std::exception& e) {
100065       {
100066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100067       };
100068     } catch (Dali::DaliException e) {
100069       {
100070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100071       };
100072     } catch (...) {
100073       {
100074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100075       };
100076     }
100077   }
100078
100079   jresult = result;
100080   return jresult;
100081 }
100082
100083
100084 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
100085   float jresult ;
100086   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100087   float arg2 ;
100088   float arg3 ;
100089   float arg4 ;
100090   float arg5 ;
100091   float result;
100092
100093   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100094   arg2 = (float)jarg2;
100095   arg3 = (float)jarg3;
100096   arg4 = (float)jarg4;
100097   arg5 = (float)jarg5;
100098   {
100099     try {
100100       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
100101     } catch (std::out_of_range& e) {
100102       {
100103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100104       };
100105     } catch (std::exception& e) {
100106       {
100107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100108       };
100109     } catch (Dali::DaliException e) {
100110       {
100111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100112       };
100113     } catch (...) {
100114       {
100115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100116       };
100117     }
100118   }
100119
100120   jresult = result;
100121   return jresult;
100122 }
100123
100124
100125 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
100126   float jresult ;
100127   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100128   float arg2 ;
100129   float arg3 ;
100130   float arg4 ;
100131   float result;
100132
100133   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100134   arg2 = (float)jarg2;
100135   arg3 = (float)jarg3;
100136   arg4 = (float)jarg4;
100137   {
100138     try {
100139       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
100140     } catch (std::out_of_range& e) {
100141       {
100142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100143       };
100144     } catch (std::exception& e) {
100145       {
100146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100147       };
100148     } catch (Dali::DaliException e) {
100149       {
100150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100151       };
100152     } catch (...) {
100153       {
100154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100155       };
100156     }
100157   }
100158
100159   jresult = result;
100160   return jresult;
100161 }
100162
100163
100164 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
100165   float jresult ;
100166   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100167   float arg2 ;
100168   float arg3 ;
100169   float result;
100170
100171   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100172   arg2 = (float)jarg2;
100173   arg3 = (float)jarg3;
100174   {
100175     try {
100176       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
100177     } catch (std::out_of_range& e) {
100178       {
100179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100180       };
100181     } catch (std::exception& e) {
100182       {
100183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100184       };
100185     } catch (Dali::DaliException e) {
100186       {
100187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100188       };
100189     } catch (...) {
100190       {
100191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100192       };
100193     }
100194   }
100195
100196   jresult = result;
100197   return jresult;
100198 }
100199
100200
100201 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
100202   float jresult ;
100203   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100204   float arg2 ;
100205   float result;
100206
100207   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100208   arg2 = (float)jarg2;
100209   {
100210     try {
100211       result = (float)(*arg1)->SnapAndClamp(arg2);
100212     } catch (std::out_of_range& e) {
100213       {
100214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100215       };
100216     } catch (std::exception& e) {
100217       {
100218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100219       };
100220     } catch (Dali::DaliException e) {
100221       {
100222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100223       };
100224     } catch (...) {
100225       {
100226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100227       };
100228     }
100229   }
100230
100231   jresult = result;
100232   return jresult;
100233 }
100234
100235
100236 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
100237   float jresult ;
100238   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100239   float arg2 ;
100240   float arg3 ;
100241   float arg4 ;
100242   float arg5 ;
100243   Dali::Toolkit::ClampState *arg6 = 0 ;
100244   float result;
100245
100246   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100247   arg2 = (float)jarg2;
100248   arg3 = (float)jarg3;
100249   arg4 = (float)jarg4;
100250   arg5 = (float)jarg5;
100251   arg6 = (Dali::Toolkit::ClampState *)jarg6;
100252   if (!arg6) {
100253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100254     return 0;
100255   }
100256   {
100257     try {
100258       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
100259     } catch (std::out_of_range& e) {
100260       {
100261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100262       };
100263     } catch (std::exception& e) {
100264       {
100265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100266       };
100267     } catch (Dali::DaliException e) {
100268       {
100269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100270       };
100271     } catch (...) {
100272       {
100273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100274       };
100275     }
100276   }
100277
100278   jresult = result;
100279   return jresult;
100280 }
100281
100282
100283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
100284   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100285
100286   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100287   {
100288     try {
100289       (*arg1)->Reference();
100290     } catch (std::out_of_range& e) {
100291       {
100292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100293       };
100294     } catch (std::exception& e) {
100295       {
100296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100297       };
100298     } catch (Dali::DaliException e) {
100299       {
100300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100301       };
100302     } catch (...) {
100303       {
100304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100305       };
100306     }
100307   }
100308
100309 }
100310
100311
100312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
100313   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100314
100315   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100316   {
100317     try {
100318       (*arg1)->Unreference();
100319     } catch (std::out_of_range& e) {
100320       {
100321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100322       };
100323     } catch (std::exception& e) {
100324       {
100325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100326       };
100327     } catch (Dali::DaliException e) {
100328       {
100329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100330       };
100331     } catch (...) {
100332       {
100333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100334       };
100335     }
100336   }
100337
100338 }
100339
100340
100341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
100342   int jresult ;
100343   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100344   int result;
100345
100346   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100347   {
100348     try {
100349       result = (int)(*arg1)->ReferenceCount();
100350     } catch (std::out_of_range& e) {
100351       {
100352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100353       };
100354     } catch (std::exception& e) {
100355       {
100356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100357       };
100358     } catch (Dali::DaliException e) {
100359       {
100360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100361       };
100362     } catch (...) {
100363       {
100364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100365       };
100366     }
100367   }
100368
100369   jresult = result;
100370   return jresult;
100371 }
100372
100373
100374 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
100375   unsigned int jresult ;
100376   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100377   bool result;
100378
100379   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100380   {
100381     try {
100382       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100383     } catch (std::out_of_range& e) {
100384       {
100385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100386       };
100387     } catch (std::exception& e) {
100388       {
100389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100390       };
100391     } catch (Dali::DaliException e) {
100392       {
100393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100394       };
100395     } catch (...) {
100396       {
100397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100398       };
100399     }
100400   }
100401
100402   jresult = result;
100403   return jresult;
100404 }
100405
100406
100407 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
100408   unsigned long jresult ;
100409   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100410   std::size_t result;
100411
100412   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100413   {
100414     try {
100415       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100416     } catch (std::out_of_range& e) {
100417       {
100418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100419       };
100420     } catch (std::exception& e) {
100421       {
100422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100423       };
100424     } catch (Dali::DaliException e) {
100425       {
100426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100427       };
100428     } catch (...) {
100429       {
100430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100431       };
100432     }
100433   }
100434
100435   jresult = (unsigned long)result;
100436   return jresult;
100437 }
100438
100439
100440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
100441   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100442   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100443
100444   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100445   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100446   {
100447     try {
100448       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
100449     } catch (std::out_of_range& e) {
100450       {
100451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100452       };
100453     } catch (std::exception& e) {
100454       {
100455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100456       };
100457     } catch (Dali::DaliException e) {
100458       {
100459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100460       };
100461     } catch (...) {
100462       {
100463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100464       };
100465     }
100466   }
100467
100468 }
100469
100470
100471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
100472   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100473   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100474
100475   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100476   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100477   {
100478     try {
100479       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
100480     } catch (std::out_of_range& e) {
100481       {
100482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100483       };
100484     } catch (std::exception& e) {
100485       {
100486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100487       };
100488     } catch (Dali::DaliException e) {
100489       {
100490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100491       };
100492     } catch (...) {
100493       {
100494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100495       };
100496     }
100497   }
100498
100499 }
100500
100501
100502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
100503   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100504   Dali::Toolkit::Control arg2 ;
100505   Dali::Toolkit::Control *argp2 ;
100506
100507   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100508   argp2 = (Dali::Toolkit::Control *)jarg2;
100509   if (!argp2) {
100510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
100511     return ;
100512   }
100513   arg2 = *argp2;
100514   {
100515     try {
100516       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
100517     } catch (std::out_of_range& e) {
100518       {
100519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100520       };
100521     } catch (std::exception& e) {
100522       {
100523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100524       };
100525     } catch (Dali::DaliException e) {
100526       {
100527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100528       };
100529     } catch (...) {
100530       {
100531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100532       };
100533     }
100534   }
100535
100536 }
100537
100538
100539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
100540   void * jresult ;
100541   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
100542
100543   {
100544     try {
100545       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
100546     } catch (std::out_of_range& e) {
100547       {
100548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100549       };
100550     } catch (std::exception& e) {
100551       {
100552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100553       };
100554     } catch (Dali::DaliException e) {
100555       {
100556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100557       };
100558     } catch (...) {
100559       {
100560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100561       };
100562     }
100563   }
100564
100565   jresult = (void *)result;
100566   return jresult;
100567 }
100568
100569
100570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
100571   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100572
100573   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100574   {
100575     try {
100576       delete arg1;
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 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
100599   Dali::RefObject *result = NULL;
100600
100601   if (arg1)
100602   {
100603     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
100604   }
100605   return result;
100606 }
100607
100608 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
100609     return (Dali::RefObject *)jarg1;
100610 }
100611
100612 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
100613     return (Dali::SignalObserver *)jarg1;
100614 }
100615
100616 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
100617     return (Dali::ConnectionTrackerInterface *)jarg1;
100618 }
100619
100620 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
100621     return (Dali::BaseHandle *)jarg1;
100622 }
100623
100624 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
100625     return (Dali::BaseHandle *)jarg1;
100626 }
100627
100628 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
100629     return (Dali::BaseHandle *)jarg1;
100630 }
100631
100632 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
100633     return (Dali::BaseHandle *)jarg1;
100634 }
100635
100636 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
100637     return (Dali::BaseHandle *)jarg1;
100638 }
100639
100640 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
100641     return (Dali::BaseHandle *)jarg1;
100642 }
100643
100644 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
100645     return (Dali::BaseHandle *)jarg1;
100646 }
100647
100648 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
100649     return (Dali::BaseHandle *)jarg1;
100650 }
100651
100652 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
100653     return (Dali::BaseHandle *)jarg1;
100654 }
100655
100656 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
100657     return (Dali::BaseHandle *)jarg1;
100658 }
100659
100660 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
100661     return (Dali::BaseHandle *)jarg1;
100662 }
100663
100664 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
100665     return (Dali::BaseHandle *)jarg1;
100666 }
100667
100668 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
100669     return (Dali::BaseHandle *)jarg1;
100670 }
100671
100672 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
100673     return (Dali::Handle *)jarg1;
100674 }
100675
100676 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
100677     return (Dali::Handle *)jarg1;
100678 }
100679
100680 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
100681     return (Dali::BaseHandle *)jarg1;
100682 }
100683
100684 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
100685     return (Dali::BaseHandle *)jarg1;
100686 }
100687
100688 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
100689     return (Dali::Handle *)jarg1;
100690 }
100691
100692 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
100693     return (Dali::BaseHandle *)jarg1;
100694 }
100695
100696 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
100697     return (Dali::Handle *)jarg1;
100698 }
100699
100700 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
100701     return (Dali::GestureDetector *)jarg1;
100702 }
100703
100704 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
100705     return (Dali::Gesture *)jarg1;
100706 }
100707
100708 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
100709     return (Dali::Handle *)jarg1;
100710 }
100711
100712 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
100713     return (Dali::Actor *)jarg1;
100714 }
100715
100716 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
100717     return (Dali::BaseHandle *)jarg1;
100718 }
100719
100720 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
100721     return (Dali::RefObject *)jarg1;
100722 }
100723
100724 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
100725     return (Dali::Actor *)jarg1;
100726 }
100727
100728 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
100729     return (Dali::GestureDetector *)jarg1;
100730 }
100731
100732 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
100733     return (Dali::Gesture *)jarg1;
100734 }
100735
100736 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
100737     return (Dali::GestureDetector *)jarg1;
100738 }
100739
100740 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
100741     return (Dali::Gesture *)jarg1;
100742 }
100743
100744 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
100745     return (Dali::GestureDetector *)jarg1;
100746 }
100747
100748 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
100749     return (Dali::Gesture *)jarg1;
100750 }
100751
100752 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
100753     return (Dali::BaseHandle *)jarg1;
100754 }
100755
100756 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
100757     return (Dali::Handle *)jarg1;
100758 }
100759
100760 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
100761     return (Dali::Handle *)jarg1;
100762 }
100763
100764 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
100765     return (Dali::Handle *)jarg1;
100766 }
100767
100768 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
100769     return (Dali::Image *)jarg1;
100770 }
100771
100772 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
100773     return (Dali::Image *)jarg1;
100774 }
100775
100776 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
100777     return (Dali::Image *)jarg1;
100778 }
100779
100780 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
100781     return (Dali::RefObject *)jarg1;
100782 }
100783
100784 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
100785     return (Dali::Image *)jarg1;
100786 }
100787
100788 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
100789     return (Dali::Image *)jarg1;
100790 }
100791
100792 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
100793     return (Dali::ResourceImage *)jarg1;
100794 }
100795
100796 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
100797     return (Dali::Actor *)jarg1;
100798 }
100799
100800 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
100801     return (Dali::BaseHandle *)jarg1;
100802 }
100803
100804 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
100805     return (Dali::BaseHandle *)jarg1;
100806 }
100807
100808
100809 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
100810     return (Dali::BaseHandle *)jarg1;
100811 }
100812
100813 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
100814     return (Dali::BaseHandle *)jarg1;
100815 }
100816
100817 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
100818     return (Dali::CustomActorImpl *)jarg1;
100819 }
100820
100821 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
100822     return (Dali::CustomActor *)jarg1;
100823 }
100824
100825 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
100826     return (Dali::BaseHandle *)jarg1;
100827 }
100828
100829 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
100830     return (Dali::Toolkit::Control *)jarg1;
100831 }
100832
100833 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
100834     return (Dali::Toolkit::Control *)jarg1;
100835 }
100836
100837 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
100838     return (Dali::Toolkit::Button *)jarg1;
100839 }
100840
100841 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
100842     return (Dali::Toolkit::Button *)jarg1;
100843 }
100844
100845 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
100846     return (Dali::Toolkit::Button *)jarg1;
100847 }
100848
100849 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
100850     return (Dali::Toolkit::Control *)jarg1;
100851 }
100852
100853 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
100854     return (Dali::Toolkit::Control *)jarg1;
100855 }
100856
100857 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
100858     return (Dali::Toolkit::Control *)jarg1;
100859 }
100860
100861 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
100862     return (Dali::Toolkit::Control *)jarg1;
100863 }
100864
100865 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
100866     return (Dali::Toolkit::Control *)jarg1;
100867 }
100868
100869 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
100870     return (Dali::RefObject *)jarg1;
100871 }
100872
100873 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
100874     return (Dali::Toolkit::Scrollable *)jarg1;
100875 }
100876
100877 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
100878     return (Dali::BaseHandle *)jarg1;
100879 }
100880
100881 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
100882     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
100883 }
100884
100885 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
100886     return (Dali::RefObject *)jarg1;
100887 }
100888
100889 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
100890     return (Dali::Toolkit::Ruler *)jarg1;
100891 }
100892
100893 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
100894     return (Dali::Toolkit::Ruler *)jarg1;
100895 }
100896
100897 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
100898     return (Dali::Toolkit::Scrollable *)jarg1;
100899 }
100900
100901 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
100902     return (Dali::Toolkit::Control *)jarg1;
100903 }
100904
100905
100906 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
100907     return (Dali::Toolkit::Control *)jarg1;
100908 }
100909
100910 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
100911     return (Dali::BaseHandle *)jarg1;
100912 }
100913
100914 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
100915     return (Dali::BaseHandle *)jarg1;
100916 }
100917
100918 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
100919     return (Dali::Toolkit::Control *)jarg1;
100920 }
100921
100922 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
100923     return (Dali::Toolkit::Control *)jarg1;
100924 }
100925
100926 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
100927     return (Dali::Toolkit::Control *)jarg1;
100928 }
100929
100930 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
100931     return (Dali::Toolkit::Control *)jarg1;
100932 }
100933
100934 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
100935     return (Dali::Toolkit::Control *)jarg1;
100936 }
100937
100938 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
100939     return (Dali::Toolkit::Control *)jarg1;
100940 }
100941
100942 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
100943     return (Dali::Toolkit::PageTurnView *)jarg1;
100944 }
100945
100946 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
100947     return (Dali::Toolkit::PageTurnView *)jarg1;
100948 }
100949
100950 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
100951     return (Dali::Toolkit::Button *)jarg1;
100952 }
100953
100954 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
100955     return (Dali::BaseHandle *)jarg1;
100956 }
100957
100958 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
100959     return (Dali::BaseHandle *)jarg1;
100960 }
100961
100962 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
100963     return (Dali::BaseHandle *)jarg1;
100964 }
100965
100966
100967 #ifdef __cplusplus
100968 }
100969 #endif
100970